Using Claude to Quickly Decompose Complex Spring Boot Logic in 100k‑Line Legacy Code

Establish a structural view before reading code

Identify module boundaries in the project tree, for example:

/home/project/src/main/java/com/icoderoad/order
├── controller
├── service
│   └── impl
├── mapper
├── domain
└── dto

Ask: which core business modules exist, are there strong couplings, and which paths are critical?

Use Claude to read a core class

Example service class:

package com.icoderoad.order.service.impl;

@Service
public class OrderServiceImpl implements OrderService {
    @Override
    public void createOrder(OrderDTO dto) {
        validate(dto);
        Order order = buildOrder(dto);
        save(order);
        sendMessage(order);
        updateStock(order);
    }
}

Prompt:

Help me analyze the business process of this method and draw the call chain.

Claude returns a structured description that turns raw code into a process understanding.

Classify business responsibilities

Helper method example:

private void validate(OrderDTO dto) {
    if (dto.getUserId() == null) {
        throw new IllegalArgumentException("userId cannot be null");
    }
}

Prompt:

Which business responsibility does this method belong to?

Claude classifies it as a validation layer. Similar classification yields layers such as business construction, persistence, and external system interaction, allowing the service to be split accordingly.

Generate a business map from complex logic

Method with multiple status‑based branches:

public void processOrder(Long orderId) {
    Order order = orderMapper.selectById(orderId);
    if (order == null) return;
    if (order.getStatus() == 1) {
        pay(order);
    } else if (order.getStatus() == 2) {
        deliver(order);
    } else if (order.getStatus() == 3) {
        complete(order);
    }
}

Prompt:

Generate a state transition diagram for this method.

Claude produces a state‑machine diagram, converting nested if‑else into a clear visual flow.

Batch analysis for large projects

Copy multiple service classes and ask Claude to:

Summarize core business processes

Identify duplicate logic

Mark possible refactoring points

This scales the analysis from a single class to dozens of classes.

Structural refactoring guided by Claude

Original tangled method:

public void createOrder(OrderDTO dto) {
    validate(dto);
    // 100 lines of business logic
    // 50 lines of inventory logic
    // 30 lines of messaging logic
}

After Claude‑suggested refactoring:

public void createOrder(OrderDTO dto) {
    validate(dto);
    Order order = orderBuilder.build(dto);
    orderRepository.save(order);
    orderDomainService.process(order);
}

Suggested module split:

/home/project/src/main/java/com/icoderoad/order
├── builder
│   └── OrderBuilder.java
├── repository
│   └── OrderRepository.java
├── domain
│   └── OrderDomainService.java

Claude can also automatically detect responsibility‑mixed classes, propose split suggestions, and generate skeleton code.

Derive a global architecture view

Prompt:

Summarize the overall architecture design of the order module.

Claude returns an architecture diagram that visualizes module interactions, providing a holistic view.

Key takeaways for AI‑assisted code analysis

Structure abstraction: method → flowchart, class → responsibility map, module → architecture diagram.

Pattern recognition: locate duplicate logic, code smells, coupling points.

Refactoring assistance: class split suggestions, layer optimization, skeleton generation.

When code exceeds 100,000 lines, productivity depends on system‑level understanding rather than line‑by‑line debugging; Claude helps transform chaotic codebases into clear structural knowledge.