Note: After months of waiting, domestic models (DS V3-0324) finally support AutoDev's capabilities. It's time to release AutoDev 2.0!

In April 2023, we developed AutoDev's first feature: AutoCRUD. After two years of rapid iteration, we've phased out this feature. The new AutoDev 2.0 is here - agent-driven AI programming has fundamentally changed our previous architecture. In AutoDev 2.0, you can:

• Use coding agent Sketch for automated programming
• Leverage automated programming planner AutoDev Planner
• Utilize system migration assistant Bridge for legacy system refactoring
• Employ Observer to dynamically monitor code changes in IDE
• Connect to tool ecosystem via Model Context Protocol (MCP)
• Use multiple open-source models in different scenarios (coding, reasoning, application, completion, etc.)
• ...

The best part? AutoDev 2.0 is open-source. You're free to use, modify, and share it. Let's explore this world of infinite possibilities together! Meanwhile, as the second-generation AI programming tool on the JetBrains IDE platform, you can fully leverage JetBrains' plugin ecosystem to empower AutoDev 2.0!

Coding Agent: Sketch​

Our motivation for developing AutoDev 2.0 came from the launch of DeepSeek V3 model. We built Sketch View using the Shire agent language, first applying it to multi-file programming support. We then integrated it into AutoDev 2.0, leveraging the rich IDEA plugin ecosystem to create better IDE programming experiences.

Interactive Decision View: Sketch View​

Sketch View provides a new interactive interface that helps you better understand architectures and make decisions. Key features:

• Interactive Design. Diverse Patch/Diff processing with Lint checks for generated code
• Developer Experience. Automatic WebView launch for compilation verification when starting dev services
• Quality & Security. Dependency security checks when generating dependency files

You can also use it to view code structures and improve code writing.

Isolated Environment Tool Invocation: DevIns​

In AutoDev 1.0, we designed DevIns DSL to build instruction abstractions for isolated environments. With DevIns instructions, AutoDev can:

• Safe Operations. Perform security checks on instructions like Shell and SQL, instead of relying on unreliable LLM analysis
• Model Agnostic. Enable tool invocation using CoT across different models without function tool dependencies
• Key Context. Enrich syntax analysis and architectural views through IDE's PSI interfaces, providing system-critical context

DevIns also integrates seamlessly with MCP ecosystem for better tool invocation.

Visible Task Planning: AutoDev Planner​

Planner is Sketch's core feature, offering a new task planning experience. With AutoDev Planner, you can:

• Visible Task Planning. Track current task progress through Pin and Planner ToolWindow
• Dynamic Task Planning. AI dynamically adjusts task plans based on context (model-dependent, may not update in real-time)
• Manual Task Execution. Manually execute unfinished tasks to better adjust planning

Combined with reasoning models like DeepSeek R1, AutoDev Planner can better adapt task planning to user needs.

Passive Error Observation: Observer​

Observer is a new Sketch feature that helps monitor code changes. It can observe:

• Test failures. Automatically sends failure context (relevant code) to models
• Build failures. Sends build logs (Gradle/Maven) to models automatically
• Dependency addition failures. Automatically reports issues to models
• ...

Through passive error observation, AutoDev better understands code changes to improve development efficiency.

Legacy System Migration Agent: AutoDev Bridge (Experimental)​

Bridge is our new feature for legacy system migration, including:

• Migration Paths. LLM-powered generation of system migration paths using "Explore-Sense-Respond" framework
• Architectural Views. AI-powered tool invocation for deep system scanning to generate C4 model-compliant blueprints
• Business Logic Analysis. Combines AST parsing and runtime call chain tracing for precise business logic restoration
• Migration Execution. Generates multi-level verification including unit tests, integration tests, and E2E tests to ensure post-migration functionality

As an experimental feature, AutoDev Bridge isn't fully mature yet, but we believe it will play important roles in future migrations.

DevOps Ecosystem Integration: Bidirectional MCP​

MCP (Model Context Protocol) is an excellent open protocol helping AI agents better understand context. In AutoDev 2.0, we've implemented bidirectional integration between MCP and JetBrains plugin ecosystem for better tool invocation:

• MCP as Tool. Encapsulates MCP through DevIns instructions to invoke third-party tools
• AutoDev as Service. Exposes AutoDev as MCP service callable by any Agent Tool

This creates seamless integration between AutoDev and the tool ecosystem, enhancing contextual capabilities and reducing hallucinations.

Others​

We've redesigned the UI configuration page. For details, refer to new documentation: https://ide.unitmesh.cc/quick-start

AutoDev 1.x Features​

AutoDev 1.x features remain available, with less-used features like AutoCRUD removed.

Tool Issues Remain: Can Efficiency Really Improve?​

Even with significant efficiency improvements, productivity gains might be limited. How much time do you actually spend writing code?????????????

Install AutoDev 2.0​

Download the latest version from GitHub: https://github.com/unit-mesh/auto-dev

Or add plugin repository via:
Settings → Plugins → Marketplace → Manage Plugin Repositories → Add
https://plugin.unitmesh.cc/updatePlugins.xml
Then search for AutoDev

We're working to relist on JetBrains Marketplace, but manual installation via source code is currently available.

Recently, we've implemented a new feature in AutoDev: AutoDev Planner, a coding task planning functionality built on the DeepSeek R1 reasoning model. Of course, besides DeepSeek R1, you can also use other models.

In AutoDev Planner, AI will generate a task plan for subsequent coding based on your input and collected context. This coding plan can then be used with other instruction-following models like DeepSeek V3 to generate code, edit code, etc.

Insight 1: Visibility of AI Coding Task Progress​

When designing AI coding agents, an interesting consideration is how users perceive coding task progress - whether they should explicitly see the progress or implicitly sense it.

Copilot Workspace: Early Explicit AI Tasks​

Last year, I experimented with GitHub Copilot Workspace for frontend development. After trying dozens of small requirements (even simple i18n translations), its performance didn't meet expectations, likely limited by GPT-4's capabilities. However, Copilot Workspace's approach remains valuable:

• Brainstorm. Conduct brainstorming for user tasks
• Task. Convert tasks into editable plans
• Execute. Execute plans to generate code Pull Requests
• PR. Submit changes as Pull Requests

Users can explicitly observe AI's thinking, editing, and execution processes, though it doesn't dynamically adjust plans (based on 2024 understanding).

Cursor: Implicit Task Automation with Retries​

The popular AI coding tool Cursor provides excellent AI Editor experience:

• Automatically collects IDE context
• Edits code
• Automatically fixes lint issues and retries on errors
• ...

While users can vaguely understand AI operations through text, frequent retries quickly obscure the process.

JetBrains Junie: Dynamic AI Task Planning​

The latest AI coding tool JetBrains Junie offers dynamic task planning:

• Analyzes problems and generates task plans
• Executes tasks step-by-step with contextual awareness
• Dynamically adjusts plans during execution

Users can observe continuous plan adjustments until task completion or termination.

Insight 2: The Potential of Reasoning Models in Task Planning​

As we know, 2024's reasoning models ("deep-thinking models") have expanded possibilities. Through experiments in AutoDev Sketch (similar to Cursor Composer's auto-coding agent), we found DeepSeek R1 outperforms other domestic models in tool invocation (based on DevIns instructions) with same context. Compared to DeepSeek V3, R1 utilizes more tools.

Ideally, we should use R1 for initial tool dialogue and secondary task planning, but its slower speed (equivalent to extra API calls) remains a constraint. However, R1's advantages remain evident, and we believe others share similar experiences.

Of course, large-scale experiments haven't been conducted due to the significant effort required to build comprehensive test datasets.

AutoDev Planner: Task Planning for Agent Programming​

Based on these insights, we developed the new anthropomorphic feature: AutoDev Planner to enhance Sketch's task planning capabilities. Core features include:

• Visible Task Planning: Track progress through Pin and Planner ToolWindow
• Dynamic Planning: AI adjusts plans contextually (model-dependent)
• Manual Task Execution: Users can manually execute pending tasks
• Plan Review: Manual model invocation for plan review (automatic review avoided due to token costs)

The core concept remains simple: invoke models to generate plans and display interactions.

Key Point 1: Reasoning Model-Based Planning​

Since reasoning models differ from regular models in prompt understanding and instruction following, we redesigned prompts for R1 compatibility.

After initial context collection and reasoning model configuration, R1 generates task plans containing: tasks, steps, and progress status. These plans are then displayed to users.

Key Point 2: Interactive Task Planning​

Unlike other AI coding tools, we emphasize task planning as critical interaction:

• Status Display:
  • Completed tasks marked
  • Manual execution for pending tasks
• Pin: Pin tasks to IDE locations
• File Interaction: Click filenames in tasks to open files
• Editing: Pause and adjust unsuitable plans
• Review: Manual plan review invocation

Visualizing tasks enhances AI coding experience - the original intention of AutoDev Planner.

Conclusion​

AutoDev Planner is a reasoning model-based task planning feature that helps users better understand AI coding progress and adjust plans. While still imperfect, we welcome issues and PRs on GitHub.

Download the latest version: https://github.com/unit-mesh/auto-dev/releases

In the realm of Agentic Coding, tool usage (Tool Use/Function calling) presents a fascinating topic. Completing a software development task requires utilizing numerous tools, extending beyond the native capabilities of IDEs and their plugin ecosystems to include various external tools like Git, Docker, Kubernetes, Jenkins, etc. How to enable AI to be aware of more tools and their usage presents an intriguing challenge.

Therefore, I spent a day implementing relevant functionalities in AutoDev: establishing AutoDev as an MCP service that can be invoked by any Agent Tool, while also enabling AutoDev to function as an MCP client capable of calling any MCP service.

Prelude 1: From Progressive AI Agent Solutions to AutoDev as MCP Service​

Within the broader context of AI Agents, such as automated Computer Use scenarios, IDEs themselves become just another invokable Agent tool. Current AI Agent implementations demonstrate a progressive approach to Agent Tool usage - as developers familiar with E2E testing know, UI automation proves highly inefficient. This explains why we wrote minimal UI automation tests when developing AutoDev.

While our current AI Coding implementation centers around IDEs, another scenario exists where Agent Tools take precedence:

• Agents obtain requirements through browser manipulation
• Agents launch IDEs to write code
• Agents operate DevOps tools for deployment
• ...

Given that Agent Tool invocation appears to be an emerging trend towards 2025, why not position AutoDev as an MCP service? This would allow any Agent Tool (including Cursor, Cline, GitHub Copilot, etc.) to leverage AutoDev's services and access high-quality IDE context.

Prelude 2: From MCP as Agent Tool Ecosystem to MCP Services as AutoDev Commands​

Previously, AutoDev prioritized leveraging IDE ecosystems and its own plugin architecture to enhance AI-supported end-to-end development workflows. However, even with enriched plugin capabilities, we still require numerous Agent Tools.

Agent Tools Define Baseline Capabilities for AI IDEs​

Our analysis of various AI Coding tools reveals that VSCode-based AI Editors demonstrate remarkably similar tooling capabilities, which can be comprehensively charted. In contrast, IDE-based AI Coding plugins (like AutoDev and JetBrains Junie) offer more sophisticated capabilities including AST manipulation, debugging, and FQN lookups - typically providing around 20 core IDE capabilities compared to VSCode's dozen.

As AI Coding expands into requirements management, deployment, and operations, the corresponding tool ecosystem will inevitably grow more diverse.

MCP Open Source Ecosystem Emerges​

The Model Context Protocol (MCP), introduced by Anthropic (creators of Claude), provides standardized interfaces for LLM applications to access external information, tools, and resources. While AutoDev offers powerful customization capabilities like Custom Agents:

• Some tools remain unpredictable (e.g., internal corporate tools)
• MCP's tool ecosystem is rapidly maturing into a standard (despite regional variations)

Since Cursor and Cline adopted MCP, numerous open-source MCP implementations have formed a thriving overseas ecosystem.

AutoDev x MCP: Bidirectional Empowerment​

Building upon MCP-related plugins and the io.modelcontextprotocol ecosystem, we developed a bidirectional empowerment framework:

• AutoDev functions as an MCP server accessible to any Agent Tool
• AutoDev operates as an MCP client invoking any MCP service

This dual approach consolidates our MCP capabilities.

AutoDev as MCP Server​

Based on JetBrains' MCP implementation, we enable AutoDev's MCP server capability (Note: Requires MCP activation in configuration). Simple JSON configuration suffices, as shown in this Cline plugin example:

{
  "mcpServers": {
    "AutoDev": {
      "command": "npx",
      "args": [
        "-y",
        "@jetbrains/mcp-proxy"
      ],
      "disabled": false,
      "autoApprove": []
    }
  }
}

The current version leverages official capabilities with some database enhancements, pending domestic MCP service availability for further expansion.

AutoDev as MCP Client​

Similarly, configure MCP services in AutoDev's Custom Agent page. Official MCP example:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Volumes/source/ai/auto-dev"
      ]
    }
  }
}

The MCP service's tools then become available in AutoDev. DevIns conversion example:

/list_directory

{
 "path": "/Volumes/source/ai/autocrud/docs/mcp"
}

Through AutoDev's powerful DevIns Commands, users can now invoke any MCP service - including AI Agents.

Additional Notes​

Life is short, I have AI.

• Detailed documentation: https://ide.unitmesh.cc/mcp
• Download latest AutoDev (v2.0.0-rc.2): https://github.com/unit-mesh/auto-dev/releases/tag/v2.0.0-rc.2

In 2023, given the limited capabilities of models at that time, we designed a series of legacy system features in AutoDev. By 2025, through successive iterations of the autonomous programming agent AutoDev Sketch, we began exploring how to apply AI agents to legacy systems, which led to the conception of AutoDev Bridge.

Why Can Large Language Models Perform Better?​

Previously, our company Thoughtworks had accumulated extensive experience in this domain, including migration strategy design and safety net construction. However, regardless of the migration pattern used (Strangler, Rehabilitator, etc.), human intervention was always ultimately required. By 2025, an increasing number of AI agents have demonstrated capabilities for automated migration, prompting us to refine our open-source solution.

Why can large language models perform better in legacy system migration?

• Designing reasonable path planning. Typically prioritizing cost considerations, LLMs serve as excellent knowledge bases for cost assessment.
• Generating architectural blueprints. By analyzing directory structures, dependency information, and APIs, AI can outline preliminary architectural blueprints for existing systems.
• Extracting business knowledge from code. Through AST analysis and other methods, AI can interpret business logic in existing code and rewrite based on it.
• Cross-language translation. Unlike regular code generation, LLMs can effectively translate code into target languages within seconds to minutes.
• Enhanced migration safety nets. Generating automated tests to validate migration correctness enables precise regression testing (Note: Frontend implementations still have limitations).
• ......

Therefore, we only need to focus on two key considerations:

• How can AI better understand legacy systems with tool assistance?
• How to reduce migration risks?

How Does AutoDev Bridge Accelerate Legacy System Migration?​

Based on our understanding of legacy system migration, we designed the initial implementation of AutoDev Bridge, which primarily includes:

• LLM-generated migration plans (Following the "Explore-Sense-Respond" framework)
• Current architecture analysis based on C4 model (Using AI tool invocations)
• Business logic analysis combining AST and call chains (AI code comprehension)
• Migration test case generation
• AI-assisted code translation
• ......

Through tight integration with IDEs, AutoDev Bridge can obtain highly accurate development context to further reduce AI hallucinations.

Explore-Sense-Respond: LLM-Generated Migration Plans​

Historically, we categorized legacy system migration as a complex problem in the Cynefin framework - where outcomes cannot be predicted and must be discovered through practice. Drawing from Cynefin philosophy, we designed AutoDev Bridge's cognitive framework: Explore first, then Sense, then Respond. Since we expect models to have a blueprint (C4 model) before taking action, we divide the process into three phases:

• Explore: Obtain basic system information through initial tool invocations (directory structures, dependencies, etc.)
• Sense: Generate preliminary architectural blueprints and migration plans based on exploration results
• Respond: Validate migration plans, generate migration test cases, and produce migration code

Adapted for domestic model capabilities, this process would utilize V3 for exploration, R1 for plan design, and V3 for response.

Architecture View-Oriented Tool Design​

To help AI better understand system architectures, we designed a series of architecture view-oriented tools.

Note: Current implementations show DeepSeek still struggles to fully comprehend C4 models, requiring further optimization.

Business Knowledge Extraction and Comprehension​

For business logic analysis, we primarily rely on API AST and call chain analysis. First obtain all APIs through webApiView, then retrieve API call chains via knowledge. Example:

/knowledge:GET#/api/blog/*

With Controller-to-Repository call chains, AI can effectively understand the business logic behind APIs.

Of course, this is a simplified example. In practice, AI needs to combine search tools to acquire additional context.

Conclusion​

As our research progresses, we will continue refining this solution to achieve better automated migration capabilities.

Follow our progress on GitHub: https://github.com/unit-mesh/auto-dev

A little over two weeks ago, after the release of DeepSeek V3, we introduced multi-file editing capabilities for Shire.

Following extensive testing, we discovered that DeepSeek V3 performs exceptionally well in programming scenarios, especially in multi-file editing contexts.

This inspired us to add a new feature—AutoDev Composer—to AutoDev, which had long lacked major updates. In developing this feature, we drew inspiration from a number of mature tools:

• The impressive Sketch rendering mechanism on Shire
• Complex system prompts from tools like Cursor and WindSurf
• The bug-ridden StreamDiff mode from Continue
• …and more

Now, there’s no need to switch to a VSCode-like IDE to craft prompts and then return to IntelliJ IDEA for debugging. With AutoDev Composer, you can handle everything directly within IntelliJ IDEA.

As an amateur project, we’ve put in a lot of effort to make this happen! 😊

Introduction paragraph text here.

In the previous version, we built AutoDev's custom Agent functionality, allowing users to create their own intelligent agents through custom capabilities to provide intelligent assistance for software development tasks.
In this version, we are introducing a new AI Agent language: DevIns (Development Instruction). DevIns enables users to describe software development tasks more efficiently while automatically processing content returned from AI Agents.

Introduction paragraph text here.

In the #51 issue of the open-source AI IDE plugin AutoDev, we designed the AI Agent capability for AutoDev. Half a year later, we have finally delivered this feature.

In AutoDev 1.7.0, you can now integrate internal AI Agents and seamlessly combine them with existing AI-assisted capabilities.

Introduction paragraph text here.

Generative AI holds tremendous potential in software development and knowledge management, which is why this technology is being increasingly adopted by enterprises. Emerging technologies like the HarmonyOS operating system introduce new concepts, development tools like DevEco Studio, the ArkTS language, and the ArkUI framework. In terms of implementation patterns, its integration with generative AI closely resembles the process of combining AI with enterprise infrastructure.

Therefore, we began exploring possibilities in AutoDev to integrate these new knowledge domains while reducing developers' learning burden.

Source code: https://github.com/unit-mesh/auto-dev

Three Experimental Features for HarmonyOS + Generative AI​

After initial discussions with the HarmonyOS team about their self-developed tools, we identified three experimental directions for AutoDev:

• Add ArkTS support. ArkTS is an application development language based on TypeScript extensions in the HarmonyOS ecosystem.
• Automatic ArkUI page generation. ArkUI is a declarative UI development framework for building distributed application interfaces. It shares similarities with our existing AutoPage feature and can generate code/UI through chain-of-thought reasoning.
• UI layout migration. Converting code from other languages/frameworks into HarmonyOS-compatible code using generative AI.

As someone who has studied Gradle, Intellij Community, DevEco Studio source code, and authored "Frontend Architecture: From Basics to Micro Frontends", I possess relevant experience with TypeScript, ArkUI, and declarative UIs. Thus, I confidently embarked on developing new AutoDev features - only to encounter numerous challenges.

1. AI Support for ArkTS Language​

After installing DevEco Studio, I discovered AutoDev didn't support TypeScript??? After testing in WebStorm, I realized the IDE difference. Using the PSIViewer plugin, I found DevEco Studio implements its own JavaScript/TypeScript PSI, e.g., com.huawei.ace.language.psi.impl.JavaScriptIdentifierNameImpl.

The reasons are apparent:

• The JavaScript plugin for IntelliJ platform is proprietary.
• Extending TypeScript syntax directly would be simpler than creating a new language.

Thus, DevEco Studio developed custom JavaScript/TypeScript modules supporting syntax highlighting, code completion, and formatting. It also introduced the ArkTS language as a TypeScript extension.

This means three new file types appear in DevEco Studio + AutoDev:

• Huawei JavaScript
• Huawei TypeScript
• Huawei ArkTS

Headache...

Our solution in AutoDev involves preliminary abstraction based on standard PSI to support documentation generation. A more robust approach would require:

1. Reusing JavaScript PSI through reflection
2. Integrating DevEco Studio's JavaScript support

Considering debugging complexity and existing xxStudio code references, we temporarily abandoned this approach - assuming HarmonyOS IDEs will eventually provide their own AI capabilities.

2. AutoArkUI: RAG-enhanced ArkUI Code Generation​

ArkUI is a declarative UI development framework for building distributed application interfaces.

Compared with ArkTS, integrating ArkUI presents more complexity. The current version focuses on generating pages using classic UI elements:

• Layouts: Row, Column, Stack, Flex, etc.
• Components: Button, Radio, Toggle, etc.

Since ChatGPT lacks knowledge of HarmonyOS updates, we adopted a two-step generation approach similar to AutoPage:

1. Analyze user requirements to select appropriate layouts and components
2. Generate corresponding ArkUI code based on detailed layout/component information

This process constitutes AutoDev's AutoArkUI feature. The step 1 prompt example:

• User: // maybe send Android Layout code, maybe some requirements
• Your Answer: [FlexLayout, Button, CheckBox, Checkbox, Button]

Considering programming DSLs' sensitivity to natural language, we use English prompts to avoid generating Chinese DSLs.

3. Migrating Android/iOS/Mini-Program Applications​

Generative AI demonstrates excellent code translation capabilities, as seen in IBM's COBOL-to-Java conversions and AutoDev's legacy system modernization features.

We've implemented layout migration support in AutoDev, though current limitations exist:

• Android layout conversion often produces errors
• Need for better static code analysis integration
• Merged functionality with AutoArkUI requires refinement

4. RAG-enhanced Chat Context: C++ NAPI etc.​

Through experimentation, we observed ChatGPT's lack of HarmonyOS knowledge. Thus, we implemented HarmonyOS-specific context in AutoDev 1.6.4:

• Basic declaration: This project is a HarmonyOS project.
• Language-specific contexts:
  • TypeScript/ArkTS: "Uses Flutter-like declarative UI framework"
  • C++: "Uses NAPI for building native Addons"

This helps guide AI:

• For frontend code: Consider Flutter-like declarative UI patterns
• For native code: Consider NAPI-based plugin architecture

These contexts are based on preliminary understanding and require refinement.

Future Directions​

Current limitations (implemented within hours):

• Android layout conversion inaccuracies
• Hardcoded component/layout information
• Lack of dynamically generated sample codes
• Incomplete C++ support
• Mini-program platform conversions

As I'm not an expert in Android/mini-program migration to HarmonyOS, challenges remain. Future improvements depend on motivation to develop more interesting features.

Introduction paragraph text here.

At the beginning of last year, our original intention for open-sourcing AutoDev was:

AutoDev is an open-source AI-assisted programming plugin for JetBrains IDEs. It can directly integrate with your requirement management systems (such as Jira, Trello, Github Issues, etc.). Within the IDE, with simple clicks, AutoDev automatically generates code based on your requirements. All you need to do is perform quality checks on the generated code. @

Today we've taken another step toward this goal: one-click generation of precision unit tests. In this article, we'll introduce features from version 1.4 (Team AI for teams) to version 1.5.3:

• Precision automated test generation. Enhanced static code analysis for more accurate constructor generation; optimized prompts distinguishing testing approaches for Spring Controllers vs Services; added multiple test template types.
• Local model enhancements. Provided AutoDev Coder dataset and models tailored for AutoDev; supported local data recording for knowledge distillation; allowed partial system prompt overriding for better custom model utilization.
• Multi-language documentation. Added support for JavaScript, Rust, Python, and improved Kotlin documentation generation logic.
• Automation workflow optimization. Introduced PrePush Review for AI-assisted code review before commit; streamlined commit message context with differentiated file/dependency change handling to reduce token usage.

Join us at: https://github.com/unit-mesh/auto-dev/ to build your own AI-assisted full-cycle coding companion.

During development, we selected ArchGuard - an open-source architecture governance platform built with Kotlin - as the pilot project for AutoDev's full-cycle AI assistance, continuously accumulating data and experience to better support Kotlin development.

1. Precision Test Generation​

Drawing from experience generating 200+ tests across 90 test classes in ArchGuard, we've continuously optimized test generation logic (though some bugs may remain).

AutoDev can now directly generate ready-to-use unit tests with certain probability.

Precise Context​

Current version provides test context containing:

• Related class information
• Complete input/output class details
• Static analysis of Service-related information
• Function parameter/return type analysis
• Spring component detection (Controller/Service) with testing rule suggestions

See implementations: JavaTestContextProvider, KotlinTestContextProvider

Unit Test Templates: Team AI​

To handle project-specific requirements (like special annotations in ArchGuard), we introduced customizable test templates for Controllers, Services, and other components. Manage templates through prompt-as-code approach and share within teams.

Documentation: https://ide.unitmesh.cc/customize/custom-test-template.html

Accurate API Test Data Generation​

Enhanced static analysis for API test data generation through JavaTestDataBuilder and KotlinTestDataBuilder.

2. Local Model Optimization​

Configure private model settings via AutoDev Coder in plugin preferences:

Public Model Knowledge Distillation​

New Recording Instruction In Local feature enables:

• Recording AI interaction data
• Internal model fine-tuning samples
• AutoDev debugging support

Plugin Prompt Overriding​

Override core chat prompts:

• Explain code
• Refactor code
• Fix issue
• Generate test

More context interfaces coming via template approach.

3. Multi-Language Documentation​

Added documentation generation support for:

• Python
• Rust
• JavaScript

Optimized Kotlin handling to prevent redundant function comments from OpenAI.

4. Automation Workflow Optimization​

PrePush Review​

AI-assisted preliminary code review before commit.

Streamlined Commit Messages​

Refined commit message generation through 167 real-world cases in ArchGuard, implementing token-efficient context handling.

Future Focus​

• Enhanced workflow automation: Better forward/backward process integration
• UX improvements: Loading states and error handling upgrades
• Test coverage expansion: Adding more unit tests for stability

Contribute at: https://github.com/unit-mesh/auto-dev/