How AI Powered a DDD‑Driven Refactor of Taobao’s Service Package System

Background

Taobao’s fast‑growing service‑package business suffered from a monolithic architecture that required 5‑8 person‑days to add a new package type. The main pain points were high development cost, massive code duplication (200‑300 lines per change), tight coupling of multiple domain logics in a 3800‑line class, and high risk of regression.

Refactor Goals

Use AI to analyze existing code and business logic, automatically discover domain boundaries and bounded contexts.

Generate repetitive DDD artifacts (domain models, service interfaces, data converters) with AI code‑generation.

Continuously monitor code quality, complexity, and duplication to refine the model.

Cut the cost of adding a new service package from 5‑8 person‑days to a configuration‑driven process.

Build an intelligent, evolvable architecture that supports rapid business changes.

Architecture Design Phase

AI‑Driven Context Extraction

The AI examined the v6 package structure and produced an initial list of bounded contexts, but it missed deeper business semantics.

Manual Correction of Contexts

Domain experts refined the AI output, producing a corrected context diagram (see image). This hybrid approach ensured accurate domain boundaries.

AI‑Assisted Context Refinement

Iterative prompts guided the AI to flesh out each context. For the “Product” context, the AI generated a detailed class table (Domain, DomainRepo, DomainService) and sample code.

Code Implementation Phase

Generating Code Skeletons

Using the technical document 技术方案--服务包模型升级.md , the AI produced skeletons in the v61.domain package, creating domain classes, repositories, and services.

AI‑Assisted Code Realisation

Case 1 – API Conversion : The AI transformed a 734‑line method ( queryConfirmableProgramList) to a new implementation, requiring only 25 manual fixes (96.6% accuracy). The new code separates steps into distinct domain services.

@Override
public SingleResponse<ConfirmableServiceProgramDTO> queryConfirmableProgramList(ConfirmableProgramQuery query){
    // step.1 parameter validation and shop info
    if(query==null||query.getShopId()==null){
        return SingleResponse.buildFailure("参数不能为空");
    }
    ShopInfoDTO shopInfo = shopQueryAbility.queryShopInfo(query.getShopId());
    if(shopInfo==null){
        return SingleResponse.buildFailure("门店不存在");
    }
    // step.2 fetch programs, filter goods, calculate price, apply activities
    // ... (logic delegated to domain services) ...
    return SingleResponse.of(result);
}

Case 2 – Version Comparison Tool : A utility class ProgramVersionComparisonUtil was generated to compare the results of two versions of queryConfirmableProgramList, adding 3098 lines of code with only 12 manual corrections (99.6% accuracy).

Refactor Effect Analysis

Architecture Decoupling

Before: 42‑line main method with ~1500 lines of intertwined logic.

After: 37‑line main method with ~720 lines of well‑structured calls.

Responsibility Separation

Pre‑refactor: All logic mixed in a single service.

Post‑refactor: Each bounded context handles its own concerns (shop, contract, product, price, activity).

Duplicate Code Elimination

Repeated product‑type checks in ten files were replaced by a single domain service.

Methods like buildDeliveryProgramTypeEnum were consolidated.

Extensibility

Adding a new product type now requires changes in only one context instead of multiple files.

Supports the open‑closed principle.

Testability

Each context can be unit‑tested independently, improving coverage.

Core Issues Before Refactor

Massive duplicate code (e.g., product‑type checks across ten files).

Business logic tightly coupled in monolithic services.

Poor extensibility – new features touched many files.

AI‑Assisted Architecture Upgrade Summary

Key Benefits

Intelligent Analysis: AI quickly identified repetition patterns and dependency graphs.

Efficient Generation: Code generation accuracy reached 99% with an 8‑10× speed boost.

Quality Assurance: Automated architecture health checks and risk warnings.

Implementation Guidelines

Human‑AI Collaboration: AI handles repetitive tasks; humans validate design decisions.

Incremental Strategy: Analyse → Design → Implement → Verify, with clear acceptance criteria at each stage.

Quality Control: All AI‑generated code must be reviewed and passed through automated linters.

Actual Outcomes

Added 3832 lines of code, with >70% AI‑generated; refactor cycle shortened by >75%.

Code volume reduced by 52%; duplicate code eliminated 100%.

Change points dropped from eight files to 1‑2 files per new feature.

Development cost for a new service package fell from 5‑8 person‑days to a configuration‑driven process.

Conclusion

The AI‑augmented DDD refactor proved that human‑machine collaboration can dramatically cut development effort, improve code quality, and enable rapid, maintainable evolution of large‑scale e‑commerce services.