Code-BT: A Code-Driven Approach to Behavior Tree Generation for Robot Tasks Planning with Large Language Models

1 Introduction

Recently, the application of Large Language Models (LLMs) in robotics has attracted considerable attention. Models from the GPT series, in particular, have demonstrated remarkable capabilities in analogical reasoning, emergent intelligence [Brown et al., 2020], and code comprehension and generation [Jiang et al., 2024a]. Several investigations have successfully leveraged LLMs for task planning in robotics. This includes translating natural language instructions into Planning Domain Definition Language (PDDL) [Aeronautiques et al., 1998], replacing traditional planners with LLMs to generate task plans [Zhou et al., 2024b], and utilizing LLMs to produce Python planning programs for specific domains and tasks [Silver et al., 2024]. Moreover, some studies have introduced world-state information to enable dynamic expansion and updates of object properties [Chen et al., 2023]. These works demonstrate that LLMs possess strong domain knowledge and common-sense priors, which are essential for many of planning tasks.

* Corresponding author.

However, despite the promising prospects of these studies, several inherent challenges have been revealed. A significant challenge is the development of domain knowledge libraries, which is still laborious and time-intensive, particularly when it necessitates frequent manual revisions. For example, a knowledge base predefined for task planning in a factory environment must be manually modified whenever there are changes in processes or equipment, otherwise, the generated task plans will fail. Another challenge is the limited generalization and flexibility across different task types. While LLMs can generate task plans for specific domains, current methods often struggle to generalize these plans to other types of tasks. For instance, a planning approach designed specifically for gear assembly may not be flexible or adaptable enough to handle household tasks. These issues highlight the gap between existing methods and the actual requirements of robotic task planning.

BTs are a control architecture that allows agents to flexibly switch between different tasks [Colledanchise and ¨Ogren, 2018], and are widely used in robot control [Colledanchise and Natale, 2021][Wen et al., 2024a]. Compared to traditional task representation methods such as finite state machines and decision trees, behavior trees offer advantages in modularity and flexibility. However, the manual design of BTs requires complex domain knowledge and tedious experiential details, which results in increased time and cost. This has spurred some explorations into automatic BTs generation methods based on LLMs. [Izzo et al., 2024][Lykov et al., 2023] construct BTs datasets to fine-tune models to improve the direct output of BTs, while [Ao et al., 2024] and [Chen et al., 2024] combine planning for BTs generation, using LLMs to transform goals into planning languages, and then using BTs expansion algorithms to construct behavior trees. However, these methods either require substantial costs in collecting or constructing datasets for fine-tuning, or building domain knowledge libraries for each individual task scenarios, which lacks generalization and flexibility.

Code represents a fundamental medium for the realization and deployment of BTs 1 2 . A fact is that LLMs have been extensively trained on high-quality code data, which has concurrently enhanced their code generation capabilities, now a key metric of their performance. This has inspired us to use code generation for the automatic design of BTs. Compared to directly generating BTs or planning languages for robotic tasks, LLMs have been extensively trained on high-level programming languages like Python. Code's primary benefit is its generality and its ability to encapsulate complex logic with expressive power. Utilizing the strong code generation abilities of LLMs, we intend to create a comprehensive and adaptable framework for BTs generation, facilitating effective task planning in diverse robotic scenarios.

We introduce a code driven approach for Behavior Trees generation Code-BT. Code-BT consists of a three-phase framework that utilizes code to assist LLMs in planning BTs for solving robotic tasks. This code generation approach is bottom-up, emulating the programmer's methodology of crafting subtask functions prior to tackling the complete task within the code. In the first phase, the LLM selects relevant code APIs according to the task instructions. Subsequently, the LLM organizes these APIs into modular solutions, while adhering to constraint rules to regulate the control flow structure. Given the inherent complexity, this process is iterative and feedback-driven, as producing an accurate and reliable solution in a single attempt is rarely feasible. Finally, we introduce a parsing algorithm to extract control flow from the generated code, mapping it into a Behavior Tree representation.

The principal contributions of this paper are as follows.

• We propose Code-BT, the first framework leveraging LLMs' code generation capabilities to automate Behavior Trees creation for robotic tasks.
• We design targeted rules to enforce structural constraints on code generated by LLMs, ensuring alignment with the BTs. To improve reliability, we incorporate an iterative feedback mechanism, organizing APIs in a bottomup manner and preserving the modularity of BTs.
• We devise an innovative algorithm leveraging Abstract Syntax Trees (ASTs) to accurately extract control flow from Python code and map it into an equivalent XMLformatted BTs representation.
• Compared to generalizable methods like Chain-ofThought (CoT) and code generation approaches, our method significantly improves BTs generation pass rate and quality across diverse task scenarios.

1 https://py-trees.readthedocs.io/en/devel/

2 https://www.behaviortree.dev/

2 RelatedWork

2.1 Planning and LearningMethods for BTs Generation

The automatic generation of BTs is a significant research direction in robotics and artificial intelligence. Some studies have focused on planning-based approaches to ensure the generated tree structures are both logical and complete. For instance, [Cai et al., 2021] introduced a STRIPS-based BTs expansion method that constructs coherent and comprehensive behavior trees using state space formulations. [Gugliermo et al., 2023] combined decision trees and logical decomposition to create interpretable behavior trees. [Rovida et al., 2017] utilized a PDDL planner to initialize task sequences, followed by hierarchical task network (HTN) decomposition to obtain hierarchical trees, which were then reorganized and optimized to generate behavior trees. [Chen et al., 2024] convert task instructions into first-order logic formulas and using the Optimal Behavior Tree Expansion Algorithm (OBTEA) to construct minimum-cost behavior trees.

Moreover, learning-based BTs generation methods have demonstrated their potential in representing patterns within BTs structures effectively. [Potteiger and Koutsoukos, 2023] employed reinforcement learning to develop an Evolving Behavior Tree (EBT) model. [Iovino et al., 2021] used genetic programming to learn the structure of behavior trees, addressing robotic tasks in unpredictable environments. [Jain et al., 2024] adopted a learning from demonstration approach to derive behavior trees from task demonstrations.

While planning-based methods ensure the reliability of the generated behavior trees, they often require substantial time and effort to manually write PDDL domain and problem files. Additionally, learning-based methods are computationally expensive, and they have limited generalization capabilities.

2.2 Integrating LLMs for Robot Program Generation

Code generation aims to automatically produce executable code from high-level abstract descriptions, such as natural language or requirement specifications, thereby reducing the workload of manual coding. In recent years, large language models (LLMs) have demonstrated significant potential in natural language processing and code generation. Recent advancements have seen the introduction of numerous LLMs, including DeepSeek v2[Liu et al., 2024] , Qwen 2.5 [Yang et al., 2024], and GPT-4[Achiam et al., 2023], which have achieved state-of-the-art (SOTA) results in various coderelated tasks, such as code generation [Wen et al., 2024b] and code summarization [Zhou et al., 2024c].

Program code serves as one of the primary interfaces for specifying robotic planning and control commands, playing a crucial role in implementing robotic functionalities and tasks[Yang et al., 2022]. Consequently, LLM-generated code can serve as an expressive means to control robots. For example, [Vemprala et al., 2024] demonstrated the ability of LLMs to generate deployable code based on task descriptions and available API information. [Liang et al., 2023] showed how LLMs can recursively generate undefined functions, enabling the development of more complex code policies for robots. Additionally, [Burns et al., 2024] illustrated the potential of LLMs to generate relevant code for high-precision manipulation tasks within the correct action space.

These studies highlight the significant potential of code generation techniques in the field of robotics. However, current methods primarily focus on low-level action control and lack the capability to handle long-term complex tasks.

2.3 Integrating LLMs for BTs Generation

The strong language understanding and reasoning capabilities of large language models (LLMs) have led researchers to explore innovative methods for directly constructing BTs using LLMs. For example, [Cao and Lee, 2023] designed a PhaseStep Prompt method that converts natural language descriptions into robot actions, thereby building complete behavior trees. In [Zhou et al., 2024a], a keyword parser based on BERT was developed to parse sequential steps into an initial behavior tree, which is subsequently dynamically expanded. Some studies have used LLMs to directly generate XMLformatted behavior trees [Izzo et al., 2024], [Mower et al., 2024]. [Ao et al., 2024] employs LLMs as planners by providing initial states, goal descriptions, and PDDL knowledge, using different context learning methods to generate behavior trees.

Unlike the aforementioned works, our approach parses behavior trees from generated high-level programming languages rather than from rough natural language descriptions. This method incorporates more precise API and control flow information and does not rely on additional training or predefined planning domain knowledge.

3 Method

In this section, we introduce the workflow and design details of our method, including API selection, code generation, and control flow to BTs mapping. Our method framework is illustrated in Figure 1. To better leverage the code generation capabilities of LLMs for generating usable behavior trees for robotic tasks, we have constructed a pipeline consisting of the following phases.

3.1 API Selection

This phase ultimately yields a set of callable API functions, which fall into two categories: condition checks and action executions.

We instruct the LLM to combine the task description with the API library to select the necessary and relevant APIs for the task, and output the results in JSON format. Given the diversity of platforms, scenarios, and tools in the robotics domain, these APIs are not limited to any specific platform or library. The API library provides a diverse set of robotic actions, including essential descriptive names and corresponding functional annotations, while hiding the intricate details of the functions, similar to the definition in [Vemprala et al., 2024].

The advantage of this method is that it significantly reduces the complexity of constructing the function library, requiring only the function names and their corresponding descriptions, which enhances its generality. Whether manually or automatically created, there is no need for specific, strict implementations or runtime details, making it easy to construct an API library. Furthermore, additional parameters or detailed comments can be added to the function headers if necessary.

Specifically, regarding the API function library, when a new scenario or task arises, relevant APIs can be easily incorporated into the library in code form, without the need for detailed function implementations. This increases the generalization across different scenarios. Additionally, the highly abstracted nature of the APIs in the library facilitates easy updates, modifications, or deletions.

3.2 Rule-ConstrainedMulti-Round Code Generation

Decision trees have been shown to be equivalent to behavior trees when action nodes always return "running" [Colledanchise and ¨Ogren, 2016], as illustrated in Figure 2. In practice, decision trees can be easily implemented using "if-else" branching structures in code. However, behavior tree nodes may return either "success" or "failure." Therefore, simple "if-else" structures are insufficient to fully represent behavior trees. There are already open-source libraries, such as pytrees, that assist in implementing behavior trees, but these libraries have not achieved the same level of popularity as ROS in the robotics operating system domain. Consequently, we aim to generate more general-purpose code to represent behavior trees without relying on complex predefined libraries.

In previous code generation tasks, benchmarks like Humaneval[Chen et al., 2021] and MBPP[Austin et al., 2021] have been used to evaluate the performance of models in generating code. However, there is currently no benchmark available for evaluating the generation capability of personalized code, such as robot functions or specific coding conventions. Notably, the work on SCoT (Structure Chain of Thought) [Li et al., 2023] explored the method of incorporating structured intermediate steps into code generation by leveraging sequence, branching, and looping structural information, which effectively improved the quality of code generation.

Inspired by decision trees and SCoT, we aim to effectively extract control structure information (control flow) from code to generate BTs. Based on the set of available API functions obtained from the previous step, we leverage the LLMs to organize these API functions through code generation. Specifically, the code generation step has three core settings:

Constraint Rules:

1. In addition to using the if-else keywords, we allow the use of not to evaluate the execution results of nodes. The return keyword is used to indicate the result, which can only be failure or success, represented by boolean values (False or True).
2. The control flow within code blocks follows two logical patterns:If the condition is not met (if not), execute the corresponding function; otherwise, return True.If the condition is met or the operation is successful (if), execute the corresponding function; otherwise, return

False.If all steps are successful, return True; otherwise, return False.

1. Each code block can only use nested if(not) statements: Specifically, nested if(not) keywords are used to determine whether to proceed with the execution of the next function. Within a code block, only one if-else structure with the lowest indentation level is allowed, and this if-else structure contains all the control structure information of a behavior tree (subtree).

These constraint rules ensure that the generated code adheres to a structured and predictable control flow. By limiting the complexity of the if-else structures and using boolean values for results, the rules facilitate the generation of reliable and efficient behavior trees.

Multi-Round Generation: For tasks involving multiple APIs, requiring the generation of code to organize all APIs in a single response increases the challenge for LLMs. Therefore, we allow the LLM to use only a subset of the API collection in a single response to generate a code block. The multi-round generation process corresponds to the generation of multiple subtrees. Each round of generation involves organizing subtrees and nodes, which fully leverages the modular advantages of behavior trees. This approach aligns the code generation process with the bottom-up modular design process of behavior trees. For example, when a robot completes the task of cleaning an ashtray, it involves stages such as moving, judging, picking up, and cleaning. During the generation process, APIs are organized into these modules, and these modules are then used to generate the final code.

Iterative Feedback: We mandate that the LLM generates responses in JSON format. To ensure compliance with constraint rules and optimize the code structure, we introduce a feedback mechanism that mitigates errors and hallucinations. This mechanism primarily includes: Output Format Validation: Verify that the output adheres to the JSON format, ensuring the completeness and accuracy of keys and values. Syntax Validation: Ensure that the generated code complies with the syntax rules of the target programming language. Rule Validation: Verify that the generated code structure aligns with the predefined rules. If the code fails validation, the system provides specific feedback to guide the model in regenerating the code. This process continues until all rules are satisfied or the maximum feedback limit is reached.

In summary, compared to approaches that either utilize sequential API functions (as illustrated in Figure 3) or adopt decision tree control architectures, our solution incorporates a richer set of keywords and control flow information. By embedding rule constraints into the code generation process, our framework subsequently maps the generated code to behavior trees for robotic control, ensuring alignment with the modular design principles of behavior trees.

3.3 Control Flow to BTs Mapping

The goal of this phase is to convert the generated Python code into XML format representing a behavior tree. Compared to the intricate details of the pytrees library, such as the writing and updating processes of nodes to the blackboard, we focus more on how the generated code organizes available APIs according to control flow to accomplish tasks. We have designed a conversion algorithm that leverages Abstract Syntax Trees (ASTs) to parse the control flow in the code and map it to the structure of a behavior tree. The main steps of the conversion algorithm are as follows:

1. Abstract Syntax Tree (AST) Parsing: Initially, we use Python's ast module to parse the generated code and generate the corresponding AST. AST is a tree-like structure that clearly extracts the syntactic structure of the code.
2. Control Flow Extraction: Based on the AST parsing, we extract control flow information from the code. Control flow information primarily includes conditional statements (such as if-else) and function calls. This control flow information will be used to construct nodes and subtrees in the behavior tree.
3. Behavior Tree Node Mapping: We map conditional statements in the code to condition nodes in the behavior tree, and API function calls to action nodes(Encapsulated functions are mapped to subtrees). For control flow structures (such as nested if-else statements), we map them to control flow nodes in the behavior tree, such as Sequence Nodes or Fallback Nodes.
4. Behavior Tree Construction: After completing the node mapping, we organize these nodes according to the structural rules of behavior trees to form a complete behavior tree, which is then output in XML format.

4 Experiments

4.1 Experimental Setup

Benchmarks: Our experiments are conducted using the BEHAVIOR-1K benchmark[Li et al., 2024], a comprehensive simulation framework designed for robotics. The tasks in BEHAVIOR-1K are characterized by their long-term nature and reliance on complex manipulation skills, presenting significant challenges for state-of-the-art robotic learning solutions. We selected 24 tasks from this benchmark to ensure a diverse representation of task scenarios and categories. For each task, we extracted their corresponding task descriptions and developed an API function library necessary for all tasks, ensuring comprehensive coverage of all required operations.

These API functions are highly abstracted but include detailed functional annotations, as illustrated in Figure 1.

LLMs: Code-BT is designed as a versatile framework, independent of any specific LLM. For our experiments, we selected four prominent LLMs: DeepseekV2.5-Chat

[DeepSeek-AI, 2024], GPT-4o[Hurst et al., 2024], Qwen2.572B-Instruct[Yang et al., 2024] (denoted as qwen2.5-72b), and Llama3.1-70B-Instruct [Dubey et al., 2024] (denoted as llama3.1-70b). These models, representing a range of parameter sizes and including both powerful open-source (Deepseek) and closed-source (GPT-4o) models, ensure diverse results and accessibility.

Compared Methods: For the task of generating behavior trees, there is currently no specific prompting method designed to directly improve performance. Therefore, we compared our method with general CoT (Chain of Thought) method, as well as code generation methods such as SCoT and CodeCoT (Code Chain of Thought). Our method and all baselines use one-shot examples and are constructed using the same problem setup. All comparison methods have been adjusted to fit the behavior tree generation process.

• CoT[Wei et al., 2022]: The standard CoT method, which generates intermediate reasoning steps before solving language reasoning tasks, has been proven effective in improving the performance of LLMs in commonsense and arithmetic reasoning.
• SCoT: SCoT is a novel code generation prompting technique that requires the LLM to use program structures (i.e., sequence, branching, and looping structures) to construct the CoT, resulting in SCoT prompts. Compared to CoT, SCoT prompts explicitly constrain the LLM to think from the perspective of source code, further enhancing the LLM's performance in code generation.
• CodeCoT: Referring to the [Jiang et al., 2024b] setup, we manually wrote detailed annotations for the behavior tree XML in the example, enabling the LLM to use the annotations as intermediate steps to guide the XML generation process.

Evaluation Metrics: BTs evaluation usually relies on manual inspection, where experts assess the correctness, functionality, and performance of the BTs. However, this approach presents several challenges: it is time-consuming, susceptible to human error, and often inconsistent due to the inherent subjectivity of manual judgment. In addition, traditional simulation tools, such as Gazebo[Koenig and Howard, 2004], are commonly used for BTs evaluation. While these simulators accurately model physical processes and environments, they come with high computational demands and inefficiencies. Moreover, these tools often require considerable effort to adapt to different scenarios, making them unsuitable for evaluating BTs across diverse task environments.

To overcome these limitations, we employ two automated evaluation methods to effectively demonstrate the improvements introduced by Code-BT: the simulator and the evaluator. The simulator allows BTs to be tested in virtual environments, ultimately assessing whether the BT can successfully complete the task. Meanwhile, the evaluator systematically evaluates various aspects of the BTs, such as its structure and logic, and provides a corresponding score.

• LLM-based Simulator: This metric is derived from the validation results of a behavior simulator [Wang et al.,

2024]. The simulator rapidly executes behavior trees and categorizes the outcomes into three types: Good, Bad Logic, and Unreachable. Behavior trees that yield a "Good" result are deemed successful, and we calculate the proportion of such successful outcomes.

• LLM-based Evaluator: We utilize Deepseek to evaluate the behavior trees, providing a comprehensive score based on five critical dimensions: logic and task completion, structure and readability, efficiency and performance, error handling and robustness, and scalability and maintainability. The total score is 100.

4.2 Method Performance

In our experiments, we divided the comparative methods into two distinct settings. One-step: The LLM directly receives the task description and outputs the XML-formatted behavior tree. Two-step: The LLM first generates code with format constraints, which is then converted into a behavior tree by the LLM. These settings allow us to systematically evaluate the effectiveness of each approach in generating behavior trees for robotic tasks. Table 1 summarizes the final experimental results. We measured the extent to which our method enhances the reasoning and planning capabilities of LLMs. For the baseline methods, we provided the robot task descriptions and available API functions as prompts to the LLMs, enabling them to integrate planning through multi-round generation. During the generation process, errors were identified, and feedback was provided for improvement. To ensure a fair comparison, we included a few demonstration examples. Across all models, Code-BT demonstrated significant performance improvements. The results indicate that CodeBT substantially increases the pass rate of behavior trees, showcasing its overall capability to generate correct behavior trees. Specifically, in terms of pass rate, our method achieved a 16.67% improvement over the highest-performing baseline method (DeepSeekV2.5, Llama3.1-70B-Instruct, GPT4o), and a 29.17% improvement (Qwen2.5-72B-Instruct).

Our method showed slightly lower improvements in LLM Evaluation, which can be attributed to the inherent limitations of LLMs. Even for humans, it is challenging to provide precise scores for behavior trees. Nevertheless, it is noteworthy that LLM Evaluation still reflects the overall effectiveness of the experiment. The suboptimal performance of the baseline methods can be attributed to the lack of training data on behavior trees for LLMs, as well as the limited effectiveness of intermediate steps in enhancing the planning of behavior tree tasks. In contrast, the application of our method brought about significant improvements. This demonstrates that the proposed Code-BT effectively addresses the challenges faced by existing LLMs in using behavior trees for task planning.

4.3 Ablation Study

In this section, we validate the effectiveness of several core mechanisms in Code-BT by exploring the following questions:

• Can the multi-round generation setting reduce the reasoning difficulty for LLMS when organizing complex tasks, thereby helping them produce better code responses?
• Can rule-constrained code generation align the control flow in the code with the control logic in behavior trees?
• Can iterative feedback correct various errors in the output of LLMs?
• Can the conversion algorithm accurately and reliably transform code into XML-formatted behavior trees?

We observe that DeepSeek and GPT-4o outperform other models, so we choose them as the main LLMs for ablation studies. We explore several ablation settings to reflect the specific effect of each mechanism. The results of the ablation study are detailed in Figure 4.

Effectiveness of Multi-Round Generation: We compared multi-round generation with one-turn generation. In multi-round generation, the model does not need to consider all functions at once. For example, in a pool-cleaning task, the model is allowed to output only the code block for "obtaining a brush" in one round, whereas one-turn generation may require the model to output the entire code for the task at once. We found that one-turn generation led to a significant performance drop 23% (DeepSeek and GPT-4o), which is attributed to the complexity of the task. Organizing all API information to write code in a single round is challenging for

(b) Score of DeepSeek and GPT-4o.

Figure 4: The ablation experiment results on DeepSeek-V2.5-Chat and GPT-4o. "w/o Rules" represents the removal of format constraint prompts, "w/o Feedback" represents the ablation of iterative feedback, and "LLMs conversion" indicates replacing the conversion algorithm with LLMs.

LLMs, leading to a substantial increase in logical errors and hallucinations. In contrast, multi-round generation reduces the reasoning difficulty for LLMs by allowing them to focus on completing "subtasks," thereby improving the reliability of the generated results.

Effectiveness of Rule Constraints: Rule constraints play a central role in the Code-BT framework, not only standardizing the structure of code generation but also ensuring that the generated code can be seamlessly converted into the control logic of behavior trees. To explore the effectiveness of rule constraints, we analyzed the following aspects:

Without rule constraints, the code generated by LLMs tends to be more free-form, potentially leading to unclear control flow or logic that does not align with behavior trees. For example, the generated code may contain non-standard return results or redundant conditional judgments, which increases the difficulty of subsequent conversion to behavior trees and may lead to logical errors in the behavior trees.

In contrast, rule-constrained code generation restricts the structure of the code (e.g., using return statements for code block execution results, limiting the complexity of if-else structures), allowing the LLMs to focus on necessary operations and ensuring that the generated code has clear control flow information. Experimental results show that ruleconstrained code generation significantly improves the pass rate and evaluation scores of behavior trees.

Effectiveness of Iterative Feedback: The iterative feedback mechanism is another core component of the Code-BT framework. When generating code, LLMs may produce format errors, logical errors, or outputs that do not comply with rule constraints. Without a feedback mechanism, these errors cannot be corrected in time, leading to lower-quality behavior trees. Therefore, the iterative feedback mechanism is designed to optimize code quality through multi-round generation and feedback, ensuring that the generated code meets task requirements.

To validate the effectiveness of iterative feedback, we conducted comparative experiments with and without iterative feedback. The results show that iterative feedback significantly improves the quality of the output (with a 41.67% improvement in pass rate on DeepSeek and a 50% improvement on GPT-4o).Through multi-round generation and feedback, the LLM can gradually optimize the code structure, generating behavior trees that better align with task requirements. Although multiple feedback rounds are allowed, most tasks achieve satisfactory results within 3 feedback iterations, indicating that the iterative feedback mechanism can quickly identify and correct issues during the generation process.

Effectiveness of the Conversion Algorithm: Mapping the generated Python code into XML-formatted behavior trees is the final phase in the Code-BT framework and a crucial step in ensuring that the generated results can be directly applied to robotic tasks. To validate the effectiveness of the conversion algorithm, we compared two methods: using the LLMs to convert Python code into XML BTs and using an ASTbased parsing algorithm to convert code into behavior trees.

The LLM-based conversion method struggles to accurately capture the control logic and action sequences in the code when dealing with complex control flows, leading to a 41.67% drop in performance on deepseek and a 29.16% drop on gpt-4o. In contrast, the conversion algorithm is designed to precisely parse the control flow information in the code. Experimental results show that the conversion algorithm can accurately map the control flow to the structure of behavior trees (nodes and subtrees), and generate behavior trees with clear logic.

5 Conclusion

This paper introduces Code-BT, a framework for the automatic generation of Behavior Trees leveraging the code generation capabilities of LLMs. Code-BT addresses the challenges of designing behavior trees for complex robotic tasks by integrating the code generation prowess of LLMs with the modular design principles of behavior trees. Experimental results demonstrate that Code-BT significantly outperforms existing baseline methods, particularly in complex tasks. Future research could focus on further optimizing Code-BT's generation mechanisms, expanding its application scenarios, and exploring more powerful LLM support to meet the demands of even more complex tasks.