Background

Recently, while organizing my projects, I also dug out the application materials for the Xiaomi MIMO developer token.

These materials were originally meant to explain what I had built with AI/Agent, but after writing them, I found they were also quite suitable as a retrospective: What exactly has AI helped me with? And where can I not hand everything over to it?

Which projects AI was involved in

Mainly two types:

The first type is complete business systems.

I used AI assistance to build a campus dormitory management system and an e-commerce platform. The former is Spring Boot + MyBatis + MySQL, and the latter is a traditional Java Web project using Servlet + JSP + DBUtils.

The second type is technical experiments.

For example, small experiments such as Spring AOP, JdbcTemplate + declarative transactions, Spring MVC interceptors, and three-layer architecture. They are not necessarily large, but they are very suitable for verifying whether a knowledge point has really been learned well.

What AI is best at

I feel AI is best suited for handling code that is “patterned but time-consuming.”

For example:

  • Structured classes such as Entity, DTO, and VO.
  • Basic templates for Controller/Service/Mapper.
  • The first version of MyBatis dynamic SQL.
  • DAO layer query code.
  • Some repetitive forms and asynchronous request snippets on the frontend.
  • Filling gaps in configuration files and things like CORS and uploads.

It is not that I cannot write these things by hand, but that it is easy to get fatigued. AI produces the first version first, and then I revise the business logic. It really is much faster.

My own experience is that efficiency for highly patterned code can improve by 50%-60%. A traditional e-commerce project that might previously have taken two weeks to grind through slowly can, with AI assistance, run through the complete flow in about one week.

But it cannot take responsibility for you

The biggest problem with code written by AI is that it “looks very much like it is correct.”

Sometimes it gives you a Controller that looks very smooth, and the method names, annotations, and return values all seem plausible. But when you actually run it, you discover that the parameters do not match, the SQL fields are wrong, and the names passed from the frontend are inconsistent with the names received by the backend.

So when I use AI to write projects now, I try to treat it as a copilot:

  • Let it produce the first version.
  • Business rules must be confirmed by myself.
  • SQL must be reviewed by myself.
  • Security boundaries must be filled in by myself.
  • In the end, I must run the complete flow myself.

AI can reduce repetitive labor, but it cannot take on engineering judgment for you.

Impact on learning

The most obvious change is that the learning cycle has become shorter.

From Java SE to Servlet, and then to Spring and Spring Boot, if I had to figure it out slowly by writing everything by hand, it might have dragged on for three months. With AI assistance, I ran through this chain in about six weeks.

But there is a prerequisite here: you cannot just copy and paste.

If you only let AI finish writing and then do not understand it yourself, then the project is not very useful even after it is done. What is truly useful is letting it generate a “first version that can run,” and then breaking it down yourself:

  • Why is this interface layered this way?
  • Why is this SQL written this way?
  • What problem does this configuration solve?
  • If the requirements change, where should I change things?

Only then will AI become a learning accelerator, rather than a code ghostwriter.

What I want to do next

Going forward, I want to continue applying AI to more realistic workflows.

For example:

  • Connect a mini-program frontend to the dormitory management system.
  • Have AI help generate unit tests.
  • Do automated code review.
  • Try connecting Agent into the backend workflow to handle some multi-step tasks.

What I feel now is that AI does not mean people no longer need to learn programming; rather, it makes “being able to ask questions, break down tasks, and accept results” more important.

Writing code is changing from “I type it line by line” to “I design, I judge, I accept.”

This is quite interesting.