Code development task execution method and device, electronic equipment, medium and product

Abstract

The present disclosure provides a code development task execution method and device, electronic equipment, medium and product, relates to the technical field of software engineering, in particular to the technical field of intelligent code development, intelligent agent and large language model. The scheme is implemented based on an intelligent development system, which includes an arrangement unit and at least one functional unit corresponding to each development stage in a development process. Each functional unit is used to execute a preset execution logic to realize a corresponding function when called by the arrangement unit. The method comprises: obtaining development requirement information for initiating a code development task; using the arrangement unit, based on the development requirement information and the current development stage, determining the functional units required to be called for each development stage, and sequentially calling each functional unit for corresponding processing to obtain the processing result of the code development task. The present scheme can automatically and efficiently link the independent steps in the development process into a complete workflow, thereby improving the development efficiency.

Description

Technical Field

[0001] This disclosure relates to the field of software engineering technology, and in particular to the fields of intelligent code development, intelligent agents, and large language model technology. Specifically, this disclosure relates to a code development task execution method, apparatus, electronic device, medium, and product. Background Technology

[0002] In code development scenarios, the development process usually covers multiple development stages, with corresponding sub-tasks executed in each stage to ultimately complete the entire development process.

[0003] In related technologies, each development stage typically involves configuring independent functional modules, such as separate processing tools. Developers need to determine the required functional modules to execute based on the current development stage. In this approach, subtasks distributed across different development stages cannot be automatically and efficiently linked into a complete and continuous workflow, impacting development efficiency. Summary of the Invention

[0004] To address at least one of the aforementioned deficiencies, this disclosure provides a method, apparatus, electronic device, medium, and product for executing code development tasks.

[0005] According to a first aspect of this disclosure, a method for executing code development tasks is provided. This method is implemented based on an intelligent development system, which includes an orchestration unit and at least one functional unit corresponding to each development stage in the development process. Each functional unit is used to execute preset execution logic to achieve a corresponding function when called by the orchestration unit. The method includes: Obtain development requirement information for initiating code development tasks; Using orchestration units, based on development requirements and the current development stage, the functional units to be called in each development stage are determined, and each functional unit is called in sequence for corresponding processing to obtain the processing results of the code development task.

[0006] According to a second aspect of this disclosure, a code development task execution apparatus is provided, implemented based on an intelligent development system. The intelligent development system includes an orchestration unit and at least one functional unit corresponding to each development stage in the development process. Each functional unit is used to execute preset execution logic to achieve a corresponding function when called by the orchestration unit. The apparatus includes: The development requirements acquisition module is used to acquire development requirements information for initiating code development tasks; The development task processing module is used to utilize orchestration units to determine the functional units to be called at each development stage based on development requirements and the current development stage, and then call each functional unit in sequence to perform corresponding processing in order to obtain the processing results of the code development task.

[0007] According to a third aspect of this disclosure, an electronic device is provided, the electronic device comprising: At least one processor; and A memory communicatively connected to at least one of the aforementioned processors; wherein, The memory stores instructions that can be executed by at least one processor, and the instructions are executed by at least one processor to enable at least one processor to execute the code development task execution method.

[0008] According to a fourth aspect of this disclosure, a non-transitory computer-readable storage medium is provided storing computer instructions, wherein the computer instructions are used to cause a computer to execute the above-described code development task execution method.

[0009] According to a fifth aspect of this disclosure, a computer program product is provided, including a computer program that, when executed by a processor, implements the above-described code development task execution method.

[0010] It should be understood that the description in this section is not intended to identify key or essential features of the embodiments of this disclosure, nor is it intended to limit the scope of this disclosure. Other features of this disclosure will become readily apparent from the following description. Attached Figure Description

[0011] The accompanying drawings are provided to better understand this solution and do not constitute a limitation of this disclosure.

[0012] Figure 1 This is a flowchart illustrating a code development task execution method provided in an embodiment of this disclosure.

[0013] Figure 2 This is a schematic diagram of the structure of an intelligent development system provided in an embodiment of this disclosure.

[0014] Figure 3 This is a schematic diagram of the structure of a code development task execution device provided in an embodiment of this disclosure.

[0015] Figure 4 This is a block diagram of an electronic device used to implement the code development task execution method provided in the embodiments of this disclosure. Detailed Implementation

[0016] The exemplary embodiments of this disclosure are described below with reference to the accompanying drawings, including various details of the embodiments to aid understanding, and should be considered merely exemplary. Therefore, those skilled in the art will recognize that various changes and modifications can be made to the embodiments described herein without departing from the scope and spirit of this disclosure. Similarly, for clarity and brevity, descriptions of well-known functions and structures are omitted in the following description.

[0017] In code development task execution technology, completing a full development task typically involves multiple distinct development phases. In related implementations, each development phase is often handled by independent functional modules, such as script tools for configuring the local development environment, transpilation tools for parsing requirements documents, engines for generating code based on prompts, and platforms for managing code submissions and reviews. During the development process, developers need to manually determine their current phase and manually select and invoke the corresponding modules. This independent invocation model necessitates repeated manual calls to different functional modules, resulting in cumbersome operations. Furthermore, the lack of automatic connection between subtasks in each development phase prevents them from being automatically linked into a complete and continuous workflow, impacting development efficiency.

[0018] Besides efficiency issues, the aforementioned independent call pattern may also lead to context loss problems. When code development tasks require traversing multiple development phases consecutively, it is necessary to accurately pass the context during the development process to multiple different functional modules to ensure the consistency of the generated code. Related technologies require frequent passing of context information between different functional modules across development phases, which can easily lead to omissions or errors in context information, affecting the overall output quality of the task.

[0019] Furthermore, code development tasks typically require the collaborative participation of various user roles, including product managers, front-end developers, back-end developers, test engineers, and operations personnel. Specific functional modules often require specialized skills from specific user roles to be effectively triggered. For example, parsing requirements documents requires a product manager to use a professional documentation tool, while code generation tools require developers to use an Integrated Development Environment (IDE). Users outside of development roles, lacking the relevant skills, may be unable to successfully trigger the execution of functional modules. Therefore, when code development tasks need to flow between different roles, the skill differences among multiple user roles create obstacles to triggering certain functional modules, making it difficult to trigger them uniformly and efficiently, thus affecting the continuity and execution efficiency of code development tasks.

[0020] The code development task execution method, apparatus, electronic device, medium, and product provided in this disclosure are intended to solve at least one of the above-mentioned technical problems of the prior art.

[0021] Figure 1 This is a flowchart illustrating a code development task execution method provided in an embodiment of this disclosure. The method is implemented based on an intelligent development system, which includes an orchestration unit and at least one functional unit corresponding to each development stage in the development process. Each functional unit is used to execute preset execution logic to achieve a corresponding function when called by the orchestration unit, such as... Figure 1 As shown, the method may include the following steps: Step S110: Obtain development requirement information for initiating code development tasks; Step S120: Using the orchestration unit, based on the development requirements information and the current development stage, determine the functional units to be called in each development stage, and call each functional unit in sequence to perform corresponding processing to obtain the processing results of the code development task.

[0022] As can be seen from the above process, in this disclosure, the orchestration unit dynamically identifies task intent based on development requirements information and different development stages, and then performs a series of calls to multiple independent functional units based on the task intent, so that sub-tasks of different development stages can be automatically linked into a complete and continuous workflow, which significantly improves development efficiency.

[0023] This disclosure enables the orchestration unit to perform intent analysis for different development stages based on development requirement information, thereby automatically calling independently encapsulated functional units for different development stages, thus automatically and efficiently connecting a complete and continuous workflow, effectively improving development efficiency.

[0024] This disclosure uses orchestration units to dynamically identify task intents based on development requirements and different development stages. Then, based on the task intents, it performs a series of calls to multiple independent functional units. This transforms loose tool collaboration into an integrated workflow that is automatically connected on demand by a unified scheduling mechanism. This solves the problem in related technologies where the lack of unified orchestration and scheduling leads to the inability to automatically connect the various links and the reliance on manual judgment and connection throughout the process. It realizes the automation of the entire development process from requirement input to code output, and significantly improves development efficiency.

[0025] The following describes in detail each step of the above process and the effects that can be further produced, with reference to the embodiments.

[0026] First, the above step S110, namely "obtaining development requirement information for initiating code development tasks", will be described in detail with reference to the embodiments.

[0027] The intelligent development system provided in this embodiment mainly includes an orchestration unit and functional units. The orchestration unit dynamically determines the functional units to be called at each development stage based on development requirements and the current development stage, and calls them sequentially to automate the entire development process. A functional unit is a software module, service, or intelligent agent that encapsulates specific processing logic; its specific form can be an independent application, script, plugin, microservice, etc. The orchestration unit can call these functional units in a unified manner, enabling the functional units to automatically execute preset execution logic to achieve the functions of the corresponding stages in the code development task.

[0028] For example, the intelligent development system provided in this disclosure can exist as a standalone, pluggable software package, which can be loaded, updated, or uninstalled by the system on demand. Each functional unit can exist as an independent plugin in this software package, and similarly supports loading, updating, or uninstalling by the system on demand.

[0029] Development requirements are the fundamental input that triggers code development tasks, and they can originate from various sources. For example, users can directly input a natural language description as development requirements through a system-integrated dialog interface; this description could express their intention to generate a product demo page. Alternatively, users can directly upload a product requirements document or provide a link to a requirements document, and the system will parse its content as development requirements. Furthermore, users can directly input a link to a Figma design file, and the system will use the corresponding design content as development requirements. In addition, development requirements can also be structured data passed from other upstream systems or workflows.

[0030] The following describes in detail step S120, namely, "using the orchestration unit, based on development requirement information and the current development stage, determine the functional units to be called in each development stage, and sequentially call each functional unit for corresponding processing to obtain the processing result of the code development task," with reference to the embodiments.

[0031] The development phase refers to different processing stages in the entire code development task process. For example, it may include, but is not limited to, the environment preparation phase for configuring the development environment, the requirements analysis phase for parsing and transcribing requirements, the code generation phase for generating code, the code review phase for verifying code, or a combination thereof. The current development phase can be determined by the orchestration unit based on the executed functional units and task progress, or it can be manually specified by the user.

[0032] After acquiring development requirements information, the orchestration unit does not simply call all functional units at once. Instead, it dynamically determines the functional units required for each stage based on the task intent reflected in the development requirements information and the current development stage. For example, the orchestration unit can determine the functional units required for subsequent stages based on whether the user-input development requirements information includes different materials such as code repository addresses, Product Requirements Documents (PRDs), Figma files, and natural language descriptions, combined with the currently completed stages. As a specific implementation method, the orchestration unit can maintain a mapping relationship between development stages and functional units and automatically generate scheduling chains based on the task intent reflected in the development requirements information.

[0033] After determining the functional units required for each development phase, the orchestration unit calls these functional units sequentially according to the phase order. Each functional unit, when called, executes its internal pre-defined execution logic, completes the processing tasks for the corresponding phase, and returns the execution result to the orchestration unit or directly passes it to the downstream functional unit. The orchestration unit can automatically trigger the next functional unit after the previous one has successfully completed, thus forming an automated task flow from start to finish.

[0034] For example, the orchestration unit may call each functional unit sequentially in a strictly serial manner, or may allow some steps to be parallelized, but it is necessary to ensure that the processing results of the upstream functional unit can be directly used by the downstream functional unit.

[0035] Finally, after all relevant functional units have completed their execution, the orchestration unit obtains the processing result of the code development task. The result can be a verified and deliverable code, a reviewed and approved code branch, or a started local service environment, etc.

[0036] The intelligent development system provided in this disclosure is an automated development system based on the collaboration of orchestration units and atomic functional units. The orchestration unit, acting as a task scheduling hub, is responsible for dynamically making decisions based on development requirements and the current development stage, and sequentially invoking corresponding functional units. Each functional unit, as a standardized module encapsulating the execution logic of a specific development stage, autonomously completes its preset atomic tasks after being activated by the orchestration unit. Through unified scheduling and context passing by the orchestration unit, this system automates the entire development process from requirement input to code output.

[0037] In summary, based on steps S110 to S120, this disclosure uses an orchestration unit to dynamically identify task intents based on development requirements and different development stages. Then, based on the task intents, it performs a series of calls to multiple independent functional units. This transforms loose tool collaboration into an integrated workflow that is automatically connected on demand by a unified scheduling mechanism. This solves the problem in related technologies where the lack of unified orchestration and scheduling leads to the inability to automatically connect various links and the reliance on manual judgment and connection throughout the process. It achieves full automation of the development process from requirement input to code output, significantly improving development efficiency.

[0038] In this solution, there is no need to rely on the professional knowledge of specific roles to trigger functional modules. Instead, the orchestration unit makes autonomous decisions and automatically schedules each functional unit based on global development requirements information and the current development stage. This solves the problems of module triggering difficulties and task connection breakpoints caused by user role permission barriers or differences in operating habits, significantly improves the participation of non-R&D roles, and improves the execution efficiency and continuity of code development tasks.

[0039] Furthermore, it's important to note that this solution differs fundamentally from conventional multi-agent collaboration in its architecture. In conventional multi-agent collaboration, the master agent typically uses independent logical reasoning to dynamically break down tasks and distribute them to sub-agents. Each sub-agent then needs to perform independent reasoning and planning to solve the problem. This process of multiple independent logical inferences introduces a high degree of uncertainty in the execution logic. This solution, however, takes a completely different approach. The orchestration unit is not directly used for task logical reasoning but rather to analyze task intent to schedule functional units with predetermined execution logic. These functional units are not used for logical reasoning specific to a particular subtask but are directly assigned specific execution logic. Based on this mechanism, the behavior of the intelligent development system provided in this solution is constrained and driven by a predefined development process and development stages, rather than by the free reasoning of agents. This eliminates reasoning uncertainty in task execution and ensures the reliability of the workflow.

[0040] As an example, Figure 2 This is a schematic diagram of the structure of an intelligent development system provided in an embodiment of this disclosure.

[0041] like Figure 2 As shown, the intelligent development system includes an orchestration unit and a set of functional units, each corresponding to a development stage in the code development process. Each functional unit is communicatively coupled to the orchestration unit. The orchestration unit can acquire development requirement information for initiating code development tasks and perceive or determine the current development stage in real time. Based on the development requirement information and the current development stage, it determines the specific functional units to be invoked for each development stage and invokes these functional units sequentially, thus forming a complete automated processing flow.

[0042] Figure 2 In the example shown, the development process includes the following stages in sequence: environment preparation, requirements analysis, code generation, and code review.

[0043] The environment preparation phase is the starting point of the code development task, aiming to bring the development environment to a ready state for subsequent tasks. The functional units corresponding to this phase include the environment configuration unit and the development specification knowledge acquisition unit. The environment configuration unit automatically corrects differences in the development environment. Specifically, it obtains the current status parameters of services already deployed in the current development environment and compares them with the target status parameters indicated by the development requirements information, automatically deploying the necessary services until the development environment has all the services required for the current code development task, i.e., the development environment is in a ready state. The environment configuration unit allows non-R&D roles to complete environment setup without needing environment configuration skills. The development specification knowledge acquisition unit automatically retrieves business design specifications, providing unified visual and interaction constraints for subsequent code generation. This unit is only called when the task is identified as a front-end page development task, and is used to access a pre-specified design system (such as the Figma design library), extract design tokens, component tokens, and generate guidance constraint files, etc., as development specification knowledge. The development specification knowledge acquisition unit ensures that the generated target code automatically aligns with business design standards.

[0044] The requirements analysis phase follows the environment preparation phase and aims to transform vague, unstructured raw requirements into structured instructions that can be directly consumed by the downstream code generation unit. The functional units corresponding to this phase include a requirements translation unit and an intent refinement unit. The requirements translation unit is used to structure and parse development requirements information and generate target prompt instructions. It extracts core functional elements (such as function point lists, interaction rules, and constraints) from development requirements information (such as PRD documents, natural language descriptions, etc.) and assembles them into hierarchical, structured target prompt instructions according to a preset template. The requirements translation unit solves the problem of distorted intent transmission caused by the free structure and inclusion of non-technical descriptions in the original requirements text. The intent refinement unit is used to proactively explore and complete vague intents. When the requirements elements extracted from the development requirements information do not cover all preset element types (such as function names, target users, interaction flows, data interfaces, etc.), the intent refinement unit can be invoked to generate structured supplementary prompt information (such as a question tab) based on the missing element types, guiding the user to complete the information, and updating the target prompt instructions based on the supplementary information. The intent-enhancing unit ensures that the target prompts for entering downstream stages contain a sufficient and clear set of elements, avoiding generation errors caused by incomplete input.

[0045] The code generation phase is the core code output stage, automatically generating executable code using the target hints output in the requirements analysis phase. The functional unit corresponding to this phase includes a code generation unit, which automatically generates target code based on structured target hints. The code generation unit can, based on the target hints output in the requirements analysis phase (and development specification knowledge, context, etc., passed by the orchestration unit), call its internal AI model or execution engine to generate compilable code that conforms to engineering specifications (such as interactive front-end demo pages or production-grade code files). The code generation unit can achieve automated generation of target code without manual coding intervention. Furthermore, the code generation unit also has interactive optimization capabilities, receiving adjustment information (such as natural language descriptions, editing operation instructions, etc.) provided by users based on the preview code, and quickly iterating and modifying the target code accordingly, achieving rapid optimization through human-machine collaboration.

[0046] The code review phase is a quality control step before code delivery, ensuring that the generated code meets predetermined specifications and quality standards. The corresponding functional unit in this phase includes a code verification unit, which automatically performs code quality verification. The code verification unit can perform verification processing on the target code based on at least one preset verification method to guarantee the quality of the generated target code.

[0047] To further optimize the uniformity and reliability of calls between functional units in the above embodiments, in one optional embodiment of this disclosure, both the orchestration unit and the functional unit are configured to execute preset execution logic based on input data that meets preset input specifications, so as to output intelligent agents that output data that meets preset output specifications.

[0048] The orchestration unit and each functional unit can be configured as an agent. Specifically, each agent executes its internal execution logic based on input data that meets preset input specifications, and ultimately outputs output data that meets preset output specifications. This mechanism achieves homogenization between the orchestration unit and the functional units at the interface level. When an orchestration unit calls any functional unit, it only needs to organize the parameters according to the functional unit's input specifications to trigger its execution; and because the output of a functional unit follows preset output specifications, its output format and structure are predictable and can be directly parsed and consumed by the orchestration unit or other functional units. For example, when the requirement translation unit is encapsulated as an agent, its input specifications can require the input data to be the URL of a PRD document or plain text, while the output specifications stipulate that the output data must be a structured prompt instruction containing requirement elements and constraints. Similarly, when the environment configuration unit is encapsulated as an agent, its input specifications can include the current service status parameters of deployed services in the development environment, while the output specifications require the return of status information describing whether the environment is ready.

[0049] In this solution, by standardizing the input and output data of the orchestration unit and the functional unit, the orchestration unit can reliably call each functional unit, and the output of any functional unit can be accurately consumed by the downstream unit, thereby improving the orchestration stability and connection reliability of the workflow.

[0050] In one optional embodiment of this disclosure, the output data of the functional unit includes context information of a preset type. This context information is provided to the orchestration unit, which then calls each functional unit to perform corresponding processing, including: By using orchestration units, context information is provided to the subsequently invoked functional units; The corresponding intelligent agent is invoked based on the context information by utilizing the subsequently invoked functional unit.

[0051] Context information refers to pre-defined types of information in the output data of functional units that can be directly consumed by subsequent functional units. The types of context information can be diverse, including but not limited to: structured prompt instruction text, design constraint file paths, project repository addresses, and business configuration parameters.

[0052] After an upstream functional unit completes its execution, its output includes not only direct business results (such as structured prompts and instructions) but also a set of pre-defined context information. This context information is not the business result itself but describes the task execution environment, state, constraints, and parameters. The orchestration unit maintains this context information and is responsible for actively extracting and caching the context information upon receiving the output from the upstream functional unit. When scheduling downstream functional units, the orchestration unit injects the accumulated context information related to the current task, along with the task parameters, into the downstream functional units. Before executing its internal logic, the downstream functional unit actively parses and applies this context information to understand the global task context and upstream processing results, thereby making decisions that better align with the overall task objectives.

[0053] In this solution, context information can be uniformly maintained by the orchestration unit, and an automatic and stable context information transmission relationship can be established between upstream and downstream functional units. This enables context information to be automatically, accurately, and completely transmitted in the task flow, ensuring that subsequent steps can operate based on the latest and most complete task status. This effectively avoids problems such as information loss or errors caused by manual transmission or repeated construction of context information in long-process code development tasks.

[0054] For example, refer to Figure 2As shown in the example, when the orchestration unit sequentially schedules the requirements translation unit and the code generation unit, after the requirements translation unit completes its execution, its output data includes not only structured target hints but also a set of contextual information, such as the code repository address. When the orchestration unit calls the code generation unit, it passes this contextual information to the code generation unit. Before starting its internal agent to execute code generation, the code generation unit can automatically read the aforementioned contextual information to ensure that the generated target code conforms to predetermined constraints.

[0055] In one optional embodiment of this disclosure, the development phase includes an environment preparation phase for configuring the development environment. The functional units corresponding to the environment preparation phase include an environment configuration unit. Based on development requirements information and the current development phase, the functional units required for each development phase are determined, and each functional unit is called sequentially for corresponding processing, including: In response to the environment preparation phase, the orchestration unit is used to obtain the current service status parameters of the deployed services in the development environment, and the target service status parameters of the required services are determined based on the development requirement information. In response to the current service status parameters not meeting the target service status parameters, the environment configuration unit is invoked to perform service configuration operations in the development environment based on the current service status parameters and the target service status parameters.

[0056] The development phase includes an environment preparation phase for configuring the development environment. The functional unit corresponding to this phase is the environment configuration unit. When the orchestration unit reaches the environment preparation phase, it first obtains the current service status parameters of the deployed services in the development environment. These deployed services include, for example, Node.js Version Manager (nvm), Node.js, and Git. The orchestration unit can obtain the current service status parameters of the deployed services, such as installation version and configuration correctness, by calling system detection scripts or reading environment snapshots.

[0057] Next, the orchestration unit determines the target service status parameters based on the development requirements. These parameters may specify, for example, the required Node.js version range and Git version for the target code repository. When the orchestration unit determines that the current service status parameters do not meet the target service status parameters, it calls the environment configuration unit to perform service configuration operations in the development environment based on the current and target service status parameters. Service configuration operations may include generating a minimal installation / upgrade plan based on the difference analysis results, and executing a series of steps according to the plan, such as service installation, version switching, code repository cloning, and project dependency installation. After completing the configuration, the environment configuration unit can also start the local development service and perform availability verification. Upon successful verification, it returns a ready status to the orchestration unit.

[0058] In this solution, the orchestration unit actively senses and compares the differences between the current environment state and the environment required by the task, and drives the environment configuration unit to automatically perform service configuration operations to fill the differences. This solves the problem of high technical skill requirements and high time consumption caused by manually configuring services in the environment preparation stage, and facilitates the rapid completion of complex development environment setup work.

[0059] In one optional embodiment of this disclosure, the development phase includes an environment preparation phase for configuring the development environment. The functional units corresponding to the environment preparation phase include a development specification knowledge acquisition unit. Based on development requirements information and the current development phase, the functional units required for each development phase are determined, and each functional unit is called sequentially for corresponding processing, including: In response to the environment preparation phase, the orchestration unit is used to obtain user role information. Based on the user role information and development requirements information, it is determined whether the code development task belongs to the front-end page development task. In response to the code development task belonging to the front-end page development task, the development specification knowledge acquisition unit is invoked to access the pre-specified design system to obtain development specification knowledge, which is used to guide the generation of development code.

[0060] In the environment preparation phase, design specification knowledge can be automatically acquired through the development specification knowledge acquisition unit to improve the standardization of the generated code.

[0061] Specifically, when the orchestration unit determines that it is currently in the environment preparation phase, it can further obtain user role information and, based on the user role information and development requirement information, determine whether the code development task belongs to the front-end page development task. User role information can be read from the current login session, including, for example, product manager, designer, or R&D engineer.

[0062] If the code development task is determined to be a front-end page development task, the orchestration unit calls the development specification knowledge acquisition unit to access the pre-specified design system. The pre-specified design system can be an authorized Figma design library or a component specification platform. The development specification knowledge acquisition unit extracts development specification knowledge from the design system, including basic style tokens, component tokens, and generation guidance constraint files. This development specification knowledge will serve as important constraints in the subsequent code generation stage, automatically injected into the generation logic to ensure that the final generated target code conforms to business design standards in terms of visual style and component usage.

[0063] Through the above solution, the orchestration unit automatically triggers access to the design system and extracts design specification knowledge based on the task type during the environment preparation phase. This solves the technical problem of the generated code being out of touch with business standards due to the inability to automatically inject design specifications, thereby ensuring that the generated target code can meet the business design specifications.

[0064] In one optional embodiment of this disclosure, the development phase further includes a requirements analysis phase following the environment preparation phase. The functional units corresponding to the requirements analysis phase include a requirements translation unit. Based on the development requirements information and the current development phase, the functional units required for each development phase are determined, and each functional unit is called sequentially for corresponding processing, including: In response to being in the requirements analysis phase, the requirements translation unit is invoked to extract requirements elements from the development requirements information, and target hint instructions are constructed based on the requirements elements. The target hint instructions are used to guide the generation of development code.

[0065] After completing the environment preparation phase, the development process can proceed to the requirements analysis phase. In the requirements analysis phase, the original development requirements need to be automatically converted into structured prompts and instructions.

[0066] Specifically, when the orchestration unit determines that it is in the requirements analysis phase, it invokes the requirements translation unit to extract requirement elements from the development requirements information and construct target prompt instructions based on these elements. Taking the PRD document as input for development requirements information, the requirements translation unit can perform document structure parsing to identify structured fields such as requirement background, feature list, interaction rules, data dependencies, and constraints in the PRD. Then, it extracts core functional elements from these fields, filtering out non-technical descriptions such as background explanations and business significance, forming a concise feature list. Finally, it assembles the feature list, interaction logic, and constraints into structured target prompt instructions.

[0067] In addition, the requirements translation unit can append contextual information such as business design token constraints and component library specifications to the target hint instructions. Target hint instructions are used to guide the downstream code generation unit in generating development code.

[0068] In this solution, the requirement translation unit realizes the automatic and accurate conversion of vague natural language descriptions into target prompts, which helps to improve the accuracy of code generation requirements, thereby improving the accuracy of subsequent code generation.

[0069] In one optional embodiment of this disclosure, the functional unit corresponding to the requirements analysis phase further includes an intent refinement unit. Based on the development requirements information and the current development phase, the functional units to be invoked at each development phase are determined, and each functional unit is invoked sequentially for corresponding processing, including: Using orchestration units, determine whether the requirement elements extracted from the development requirement information include all preset element types; In response to the requirement element not including all preset element types, the intent improvement unit is invoked to generate supplementary question prompts based on the preset element types not included in the requirement element, and the supplementary question prompts are provided to the user; in response to obtaining supplementary requirement information provided by the user based on the supplementary question prompts, the target prompt instruction is updated based on the supplementary requirement information.

[0070] To address situations where users' original requirements are vague or incomplete, the functional units corresponding to the requirements analysis phase may also include an intent refinement unit. In specific implementation, the orchestration unit first determines whether the requirement elements extracted from the development requirement information include all preset element types.

[0071] For example, the preset element types may include: function name, target user, interaction flow, data interface requirements, constraints, etc.

[0072] If the orchestration unit determines that the required elements do not include all the preset element types, it calls the intent improvement unit to generate supplementary question prompts based on the missing preset element types and provides the supplementary question prompts to the user.

[0073] For example, the follow-up question prompts could be a structured list of questions presented in the form of question tabs, guiding users to gradually fill in the vague intent.

[0074] Once the orchestration unit obtains the supplementary requirement information provided by the user based on the supplementary question prompt information, it updates the target prompt instruction based on the supplementary requirement information, thereby obtaining a structured prompt instruction with complete elements and clear intent.

[0075] In this solution, the orchestration unit drives the intent improvement unit to perform completeness verification on the extracted requirements, and actively generates structured supplementary prompts for missing element types, triggering interaction with the user to obtain supplementary information. This ensures that the prompts entering the downstream code generation stage contain a sufficient and clear set of elements, avoiding the impact of ambiguous input on the accuracy of the generated code.

[0076] In one optional embodiment of this disclosure, the development phase further includes a code generation phase following the environment preparation phase. The functional units corresponding to the code generation phase include a code generation unit. Based on development requirements information and the current development phase, the functional units to be invoked for each development phase are determined, and each functional unit is invoked sequentially for corresponding processing, including: In response to being in the code generation phase, the code generation unit generates target code based on the target prompt instructions.

[0077] After completing the requirements analysis and receiving the target hints, the development process enters the code generation phase. The functional unit corresponding to the code generation phase includes a code generation unit. In response to being in the code generation phase, the orchestration unit utilizes the code generation unit to generate target code based on the target hints.

[0078] The code generation unit is used to automatically generate target development code based on structured target prompts. The code generation unit can be an agent containing a generative model.

[0079] For example, the generated target code can be a set of interactive demo pages containing HyperText Markup Language (HTML), Cascading Style Sheets (CSS), and JavaScript (a scripting language), or it can directly output production-grade code files that conform to the project directory structure.

[0080] For example, target hints can also include contextual information, such as design token constraints and component library specifications. By understanding this contextual information, the code generation unit can ensure that the generated target code is consistent with the rest of the project in terms of visual style and code structure.

[0081] In this solution, the code generation unit can automatically generate target code based on structured target prompts, thus achieving automated code development and effectively improving development efficiency.

[0082] In one alternative embodiment of this disclosure, after generating the target code, the method further includes: The code generation unit is invoked to provide the target code to the user; in response to obtaining the user's adjustment information for the target code, the target code is adjusted based on the adjustment information.

[0083] In addition to automatically generating target code, the code generation unit can also support optimization of the target code based on user interaction.

[0084] Specifically, the code generation unit can be embedded in a front-end interactive interface, providing the target code to the user for preview. Users can provide adjustment information through natural language, manual editing, or by providing supplementary design reference images within the front-end interactive interface. After receiving the user's adjustment information, the code generation unit adjusts the target code based on this information and presents the adjusted code back to the user. This interactive optimization process can be iterated repeatedly until the user confirms the final target code.

[0085] In this solution, the code generation unit not only efficiently produces target code through automated generation, but also supports interactive optimization by users, which can effectively improve the quality of the delivered code while ensuring development efficiency.

[0086] In one optional embodiment of this disclosure, the development phase further includes a code review phase following the code generation phase. The functional units corresponding to the code review phase include a code verification unit. Based on development requirements and the current development phase, the functional units required for each development phase are determined, and each functional unit is called sequentially for corresponding processing, including: In response to being in the code review stage, the target code is verified using a code verification unit based on at least one preset verification method.

[0087] After code generation and optimization, the development process can proceed to the code review stage. The functional unit corresponding to the code review stage includes a code verification unit. In response to being in the code review stage, the orchestration unit utilizes the code verification unit to verify the target code based on at least one preset verification method.

[0088] For example, the code verification unit can have multiple built-in verification rules to verify the target code. The code verification unit can also provide a manual verification initiation mechanism. Specifically, the code verification unit can generate a functional description of the target code and a verification requirement description, and then, based on a predetermined transmission link, submit a verification request containing the functional description and verification requirement description to the corresponding verification user. After the verification user completes the verification and submits the verification result, the final verification result is obtained.

[0089] In this solution, the verification unit automatically verifies the target code, allowing the code verification operation to be fully integrated into the entire development process, thereby ensuring the quality of the delivered code.

[0090] In one alternative embodiment of this disclosure, the method further includes: During the sequential invocation of each functional unit for corresponding processing, in response to a pre-set exception event occurring during the execution of any functional unit, the orchestration unit pauses the code development task, generates an exception message, and provides the exception message to the user; in response to the elimination of the exception event, the code development task continues to be executed.

[0091] In order to ensure the stable execution of long-chain code development tasks, this disclosure also sets up an exception handling mechanism.

[0092] Specifically, during the process of the orchestration unit sequentially calling each functional unit for corresponding processing, if a preset abnormal event occurs during the execution of any functional unit, such as environment dependency installation failure, requirement intent ambiguity exceeding a threshold, demo generation failure, code push conflict, etc., the orchestration unit can pause the entire code development task, generate an exception message, and provide the exception message to the user.

[0093] Error messages can include a clear description of the problem and possible solution options to guide the user in handling it. Once the user resolves the error, the orchestration unit resumes code development from the point of interruption or an appropriate location.

[0094] In this solution, the execution status of each functional unit is monitored globally by the orchestration unit. When a predefined abnormal event is captured, the process is automatically paused and a clear problem description is generated to prompt the user to intervene. After the abnormality is eliminated, automatic execution can be resumed from the interruption point. This solves the problem of poor execution stability caused by the lack of an exception handling mechanism in long-chain automated tasks, ensures the stable execution of code development tasks under abnormal conditions, and improves the success rate of task execution.

[0095] The foregoing has described specific embodiments of this specification. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps recited in the claims may be performed in a different order than that shown in the embodiments and may still achieve the desired result. Furthermore, the processes depicted in the drawings do not necessarily require the specific or sequential order shown to achieve the desired result. In some embodiments, multitasking and parallel processing are possible or may be advantageous.

[0096] According to another embodiment, a code development task execution device is provided. This device is based on an intelligent development system, which includes an orchestration unit and at least one functional unit corresponding to each development stage in the development process. Each functional unit is used to execute preset execution logic to achieve a corresponding function when invoked by the orchestration unit. Figure 3 A schematic diagram of the structure of the code development task execution device according to one embodiment is shown. Figure 3As shown, the code development task execution device 300 includes: The development requirement acquisition module 310 is used to acquire development requirement information for initiating code development tasks; The development task processing module 320 is used to determine the functional units to be called in each development stage based on the development requirements information and the current development stage using the orchestration unit, and to call each functional unit in sequence to perform corresponding processing in order to obtain the processing results of the code development task.

[0097] As an alternative approach, both the orchestration unit and the functional unit are configured to execute preset execution logic based on input data that meets preset input specifications, so as to output intelligent agents that output data that meets preset output specifications.

[0098] As an optional approach, the output data of the functional unit includes context information of a preset type. This context information is provided to the orchestration unit, and the development task processing module 320, when calling each functional unit for corresponding processing, specifically uses it for: By using orchestration units, context information is provided to the subsequently invoked functional units; The corresponding intelligent agent is invoked based on the context information by utilizing the subsequently invoked functional unit.

[0099] As an optional approach, the development phase includes an environment preparation phase for configuring the development environment. The functional units corresponding to this phase include an environment configuration unit. When the development task processing module 320 determines the functional units required for each development phase based on development requirements and the current development phase, and sequentially calls these functional units for corresponding processing, it is specifically used for: In response to the environment preparation phase, the orchestration unit is used to obtain the current service status parameters of the deployed services in the development environment, and the target service status parameters of the required services are determined based on the development requirement information. In response to the current service status parameters not meeting the target service status parameters, the environment configuration unit is invoked to perform service configuration operations in the development environment based on the current service status parameters and the target service status parameters.

[0100] As an optional approach, the development phase includes an environment preparation phase for configuring the development environment. The functional units corresponding to this phase include a development specification knowledge acquisition unit. The development task processing module 320, based on development requirements and the current development phase, determines the functional units required for each development phase and sequentially calls each functional unit for corresponding processing. Specifically, it is used for: In response to the environment preparation phase, the orchestration unit is used to obtain user role information. Based on the user role information and development requirements information, it is determined whether the code development task belongs to the front-end page development task. In response to the code development task belonging to the front-end page development task, the development specification knowledge acquisition unit is invoked to access the pre-specified design system to obtain development specification knowledge, which is used to guide the generation of development code.

[0101] As an optional approach, the development phase also includes a requirements analysis phase following the environment preparation phase. The functional units corresponding to the requirements analysis phase include a requirements translation unit. When the development task processing module 320 determines the functional units required for each development phase based on the development requirements information and the current development phase, and sequentially calls each functional unit for corresponding processing, it is specifically used for: In response to being in the requirements analysis phase, the requirements translation unit is invoked to extract requirements elements from the development requirements information, and target hint instructions are constructed based on the requirements elements. The target hint instructions are used to guide the generation of development code.

[0102] As an optional approach, the functional units corresponding to the requirements analysis phase also include an intent refinement unit. When the development task processing module 320 determines the functional units to be called for each development stage based on the development requirements information and the current development stage, and sequentially calls each functional unit for corresponding processing, it is specifically used for: Using orchestration units, determine whether the requirement elements extracted from the development requirement information include all preset element types; In response to the requirement element not including all preset element types, the intent improvement unit is invoked to generate supplementary question prompts based on the preset element types not included in the requirement element, and the supplementary question prompts are provided to the user; in response to obtaining supplementary requirement information provided by the user based on the supplementary question prompts, the target prompt instruction is updated based on the supplementary requirement information.

[0103] As an optional approach, the development phase also includes a code generation phase following the environment preparation phase. The functional units corresponding to the code generation phase include a code generation unit. When the development task processing module 320 determines the functional units to be called for each development phase based on development requirements information and the current development phase, and sequentially calls each functional unit for corresponding processing, it is specifically used for: In response to being in the code generation phase, the code generation unit generates target code based on the target prompt instructions.

[0104] As an alternative, the above-mentioned device also includes The code adjustment module (not shown in the figure) is used to call the code generation unit after the target code is generated and provide the target code to the user; in response to obtaining the user's adjustment information for the target code, the target code is adjusted based on the adjustment information.

[0105] As an optional approach, the development phase also includes a code review phase following the code generation phase. The functional units corresponding to the code review phase include a code verification unit. When the development task processing module 320 determines the functional units required for each development phase based on development requirements and the current development phase, and sequentially calls each functional unit for corresponding processing, it is specifically used for: In response to being in the code review stage, the target code is verified using a code verification unit based on at least one preset verification method.

[0106] As an alternative, the above-mentioned device also includes The exception prompt module (not shown in the figure) is used to pause the code development task, generate an exception prompt message, and provide the exception prompt message to the user when a preset exception event occurs during the execution of any functional unit during the sequential calling of each functional unit for corresponding processing; and to continue the execution of the code development task when the exception event is eliminated.

[0107] The various embodiments in this specification are described in a progressive manner. Similar or identical parts between embodiments can be referred to mutually. Each embodiment focuses on its differences from other embodiments. In particular, for system or system embodiments, since they are fundamentally similar to method embodiments, the description is relatively simple; relevant parts can be referred to the descriptions in the method embodiments. The systems and system embodiments described above are merely illustrative. Units described as separate components may or may not be physically separate. Components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the modules can be selected to achieve the purpose of this embodiment according to actual needs. Those skilled in the art can understand and implement this without creative effort.

[0108] The collection, storage, use, processing, transmission, provision, and disclosure of any type of information, such as user personal information, in this technical solution comply with relevant laws and regulations and do not violate public order and good morals.

[0109] According to embodiments of this disclosure, this disclosure also provides an electronic device, a readable storage medium, and a computer program product.

[0110] Figure 4A schematic block diagram of an example electronic device 400 that can be used to implement embodiments of the present disclosure is shown. The electronic device is intended to represent various forms of digital computers, such as laptop computers, desktop computers, workstations, personal digital assistants, servers, blade servers, mainframe computers, and other suitable computers. The electronic device may also represent various forms of mobile devices, such as personal digital assistants, cellular phones, smartphones, wearable devices, and other similar computing devices. The components shown herein, their connections and relationships, and their functions are merely illustrative and are not intended to limit the implementation of the present disclosure described and / or claimed herein.

[0111] like Figure 4 As shown, device 400 includes a computing unit 401, which can perform various appropriate actions and processes based on a computer program stored in read-only memory (ROM) 402 or a computer program loaded from storage unit 408 into random access memory (RAM) 403. RAM 403 may also store various programs and data required for the operation of device 400. The computing unit 401, ROM 402, and RAM 403 are interconnected via bus 404. Input / output (I / O) interface 405 is also connected to bus 404.

[0112] Multiple components in device 400 are connected to I / O interface 405, including: input unit 406, such as keyboard, mouse, etc.; output unit 407, such as various types of monitors, speakers, etc.; storage unit 408, such as disk, optical disk, etc.; and communication unit 409, such as network card, modem, wireless transceiver, etc. Communication unit 409 allows device 400 to exchange information / data with other devices through computer networks such as the Internet and / or various telecommunications networks.

[0113] The computing unit 401 can be a variety of general-purpose and / or special-purpose processing components with processing and computing capabilities. Some examples of the computing unit 401 include, but are not limited to, a central processing unit (CPU), a graphics processing unit (GPU), various special-purpose artificial intelligence (AI) computing chips, various computing units running machine learning model algorithms, a digital signal processor (DSP), and any suitable processor, controller, microcontroller, etc. The computing unit 401 performs the code development task execution method described above. For example, in some embodiments, the above-described code development task execution method can be implemented as a computer software program tangibly contained in a machine-readable medium, such as storage unit 408. In some embodiments, part or all of the computer program can be loaded and / or installed on device 400 via ROM 402 and / or communication unit 409. When the computer program is loaded into RAM 403 and executed by the computing unit 401, one or more steps of the code development task execution method described above can be performed. Alternatively, in other embodiments, the computing unit 401 can be configured to perform the code development task execution method described above by any other suitable means (e.g., by means of firmware).

[0114] Various embodiments of the systems and techniques described above herein can be implemented in digital electronic circuit systems, integrated circuit systems, field-programmable gate arrays (FPGAs), application-specific integrated circuits (ASICs), application-specific standard products (ASSPs), systems-on-a-chip (SoCs), complex programmable logic devices (CPLDs), computer hardware, firmware, software, and / or combinations thereof. These various embodiments may include implementations in one or more computer programs that can be executed and / or interpreted on a programmable system including at least one programmable processor, which may be a dedicated or general-purpose programmable processor, capable of receiving data and instructions from a storage system, at least one input device, and at least one output device, and transmitting data and instructions to the storage system, the at least one input device, and the at least one output device.

[0115] The program code used to implement the methods of this disclosure may be written in any combination of one or more programming languages. This program code may be provided to a processor or controller of a general-purpose computer, special-purpose computer, or other programmable data processing apparatus, such that when executed by the processor or controller, the program code causes the functions / operations specified in the flowcharts and / or block diagrams to be implemented. The program code may be executed entirely on a machine, partially on a machine, as a standalone software package partially on a machine and partially on a remote machine, or entirely on a remote machine or server.

[0116] In the context of this disclosure, a machine-readable medium can be a tangible medium that may contain or store a program for use by or in conjunction with an instruction execution system, apparatus, or device. A machine-readable medium can be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium can be, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination of the foregoing. More specific examples of machine-readable storage media include electrical connections based on one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing.

[0117] To provide interaction with a user, the systems and techniques described herein can be implemented on a computer having: a display device for displaying information to the user (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor); and a keyboard and pointing device (e.g., a mouse or trackball) through which the user provides input to the computer. Other types of devices can also be used to provide interaction with the user; for example, feedback provided to the user can be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user can be received in any form (including sound input, voice input, or tactile input).

[0118] The systems and technologies described herein can be implemented in computing systems that include backend components (e.g., as a data server), or computing systems that include middleware components (e.g., an application server), or computing systems that include frontend components (e.g., a user computer with a graphical user interface or web browser through which a user can interact with implementations of the systems and technologies described herein), or any combination of such backend, middleware, or frontend components. The components of the system can be interconnected via digital data communication of any form or medium (e.g., a communication network). Examples of communication networks include local area networks (LANs), wide area networks (WANs), and the Internet.

[0119] Computer systems can include clients and servers. Clients and servers are generally located far apart and typically interact via communication networks. Client-server relationships are created by computer programs running on the respective computers and having a client-server relationship with each other. Servers can be cloud servers, servers in distributed systems, or servers incorporating blockchain technology.

[0120] This disclosure also provides a non-transitory computer-readable storage medium storing computer instructions, wherein the computer instructions are used to cause a computer to execute the above-described code development task execution method.

[0121] This disclosure also provides a computer program product, including a computer program that, when executed by a processor, implements the above-described code development task execution method.

[0122] It should be understood that the various forms of processes shown above can be used to rearrange, add, or delete steps. For example, the steps described in this disclosure can be executed in parallel, sequentially, or in different orders, as long as the desired result of the technical solution disclosed in this disclosure can be achieved, and this is not limited herein.

[0123] The specific embodiments described above do not constitute a limitation on the scope of protection of this disclosure. Those skilled in the art should understand that various modifications, combinations, sub-combinations, and substitutions can be made according to design requirements and other factors. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of this disclosure should be included within the scope of protection of this disclosure.

Claims

1. A method for executing code development tasks, based on an intelligent development system, the intelligent development system comprising an orchestration unit and at least one functional unit corresponding to each development stage in the development process, each functional unit being used to execute preset execution logic to achieve a corresponding function when called by the orchestration unit, the method comprising: Obtain development requirement information for initiating code development tasks; Using the orchestration unit, based on the development requirements information and the current development stage, the functional units to be called in each development stage are determined, and each functional unit is called in sequence for corresponding processing to obtain the processing result of the code development task.

2. The method according to claim 1, wherein, Both the orchestration unit and the functional unit are configured to execute the preset execution logic based on input data that meets the preset input specifications, so as to output intelligent agents that meet the preset output specifications.

3. The method according to claim 2, wherein, The output data of the functional unit includes context information of a preset type. The context information is provided to the orchestration unit, and the invocation of each functional unit for corresponding processing includes: The orchestration unit is used to provide the context information to the subsequently invoked functional unit. The corresponding intelligent agent is invoked based on the context information using the subsequently invoked functional unit.

4. The method according to any one of claims 1-3, wherein, The development phase includes an environment preparation phase for configuring the development environment. The functional units corresponding to the environment preparation phase include an environment configuration unit. Based on the development requirements information and the current development phase, the functional units required for each development phase are determined, and each functional unit is called sequentially for corresponding processing, including: In response to being in the environment preparation phase, the orchestration unit is used to obtain the current service status parameters of the deployed services in the development environment, and the target service status parameters of the required services are determined based on the development requirement information. In response to the current service status parameters not meeting the target service status parameters, the environment configuration unit is invoked to perform service configuration operations in the development environment based on the current service status parameters and the target service status parameters.

5. The method according to any one of claims 1-3, wherein, The development phase includes an environment preparation phase for configuring the development environment. The functional units corresponding to the environment preparation phase include a development specification knowledge acquisition unit. Based on the development requirements information and the current development phase, the functional units to be invoked for each development phase are determined, and each functional unit is invoked sequentially for corresponding processing, including: In response to being in the environment preparation phase, the orchestration unit obtains user role information, and based on the user role information and the development requirement information, determines whether the code development task belongs to the front-end page development task. In response to the fact that the code development task belongs to the development task of the front-end page, the development specification knowledge acquisition unit is invoked to access the pre-specified design system to obtain development specification knowledge, which is used to guide the generation of development code.

6. The method according to claim 4 or 5, wherein, The development phase also includes a requirements analysis phase following the environment preparation phase. The functional units corresponding to the requirements analysis phase include a requirements translation unit. Based on the development requirements information and the current development phase, the functional units required for each development phase are determined, and each functional unit is sequentially invoked for corresponding processing, including: In response to being in the requirements analysis phase, the requirements translation unit is invoked to extract requirements elements from the development requirements information and construct target prompt instructions based on the requirements elements. The target prompt instructions are used to guide the generation of development code.

7. The method according to claim 6, wherein, The functional units corresponding to the requirements analysis phase also include an intent refinement unit. Based on the development requirements information and the current development phase, the functional units required for each development phase are determined, and each functional unit is called sequentially for corresponding processing, including: Using the orchestration unit, it is determined whether the requirement elements extracted from the development requirement information include all preset element types; In response to the requirement element not including all preset element types, the intent improvement unit is invoked to generate supplementary question prompts based on the preset element types not included in the requirement element, and the supplementary question prompts are provided to the user; in response to obtaining supplementary requirement information provided by the user based on the supplementary question prompts, the target prompt instruction is updated based on the supplementary requirement information.

8. The method according to claim 6 or 7, wherein, The development phase also includes a code generation phase following the environment preparation phase. The functional units corresponding to the code generation phase include a code generation unit. Based on the development requirements information and the current development phase, the functional units to be called in each development phase are determined, and each functional unit is called sequentially for corresponding processing, including: In response to being in the code generation phase, the code generation unit generates target code based on the target prompt instruction.

9. The method according to claim 8, wherein, After generating the target code, the method further includes: The code generation unit is invoked to provide the target code to the user; in response to obtaining the user's adjustment information regarding the target code, the target code is adjusted based on the adjustment information.

10. The method according to claim 8 or 9, wherein, The development phase also includes a code review phase following the code generation phase. The functional units corresponding to the code review phase include a code verification unit. Based on the development requirements information and the current development phase, the functional units to be invoked for each development phase are determined, and each functional unit is invoked sequentially for corresponding processing, including: In response to being in the code review stage, the code verification unit verifies the target code based on at least one preset verification method.

11. The method according to any one of claims 1-10, further comprising: During the sequential invocation of each of the aforementioned functional units for corresponding processing, in response to a preset abnormal event occurring during the execution of any of the aforementioned functional units, the orchestration unit pauses the code development task, generates an abnormal prompt message, and provides the abnormal prompt message to the user. Once the abnormal event is resolved, the code development task continues.

12. A code development task execution device, implemented based on an intelligent development system, the intelligent development system comprising an orchestration unit and at least one functional unit corresponding to each development stage in the development process, each functional unit being used to execute preset execution logic to achieve a corresponding function when called by the orchestration unit, the device comprising: The development requirements acquisition module is used to acquire development requirements information for initiating code development tasks; The development task processing module is used to utilize the orchestration unit to determine the functional units to be called in each development stage based on the development requirements information and the current development stage, and sequentially call each functional unit to perform corresponding processing in order to obtain the processing result of the code development task.

13. An electronic device, comprising: At least one processor; as well as A memory communicatively connected to the at least one processor; wherein, The memory stores instructions that can be executed by the at least one processor to enable the at least one processor to perform the method of any one of claims 1-11.

14. A non-transitory computer-readable storage medium storing computer instructions, wherein, The computer instructions are used to cause the computer to perform the method according to any one of claims 1-11.

15. A computer program product comprising a computer program that, when executed by a processor, implements the method according to any one of claims 1-11.

Images