I Had an AI Read 20 Years' Worth of Source Code

Better late than never, I'm now completely hooked on AI coding.

If I were to list the things I've been doing lately,

• Source Code Analysis of “FlexInspector,” Which Has Been in Development for Over 20 Years
• Analysis of the source code, investigation of bugs, and improvements to the “FIS-100/200,” which has been in use for over 10 years
• Creating Design Specifications for a Next-Generation Visual Inspection Operating System

It is.

We're pushing this forward at full speed.

Of course, 6,000 AI Credits will be gone in the blink of an eye.

However, after using it for that long, my perspective on AI coding has changed quite a bit.

It's not just about having AI write code

When it comes to AI coding,

"I explain the specifications and have someone write the program for me."

That's the first way I imagine using it.

Of course, that's convenient, too.

However, I’m starting to think that for a company with many years of experience in software development, a different approach might actually be more valuable.

It involves having the AI read past source code.

Software that has been in development for over 20 years naturally contains a vast amount of code.

There's also some old code.

If I were writing it now, there are some parts I would write differently.

In some places, the design intent is difficult to understand.

At the same time, that code embodies more than 20 years of real-world problems encountered on the job and the experience gained from solving them.

You can't achieve this just by writing new code.

Rereading 20-Year-Old Code from Today's Perspective

FlexInspector is visual inspection software that has been in continuous development for over 20 years.

Of course, the development environment is different from what it is today.

The operating systems are different, too.

The image processing libraries are different, too.

The way we think about programming is changing, too.

Still, since this software has been refined through actual use on the production floor, it incorporates a wealth of know-how.

In the past, a person would have had to decipher that code line by line.

This is quite a challenge.

However, when using AI,

"What are we doing in this class?"

"Is there any risk in holding this pointer this way?"

"Why is this process done in this order?"

"If we migrate to the current library, what areas are likely to cause problems?"

We can have quite in-depth discussions about these kinds of things while looking at the code.

Of course, I don't just take the AI's answers at face value.

Ultimately, humans make the decision.

However, the speed at which I can read and understand code has changed significantly.

Using AI for Defect Investigation

The same applies to the FIS-100/200, which I’ve been using for over 10 years.

With software that has been in use for a long time, it’s not as simple as just saying, “We should just rebuild it from scratch.”

It's actually in operation at the factory.

Our customers are using it.

Backward compatibility is also necessary.

In addition, some parts have become more complex as a result of years of refinement.

Lately, when dealing with bugs that have occurred, I’ve been working with AI to analyze the dumps and source code,

"Is this really the cause?"

"Is there any other code with the same structure?"

"Rather than making piecemeal fixes, shouldn't we address this at the design level?"

That's as far as I've looked into it.

It's not just a matter of fixing one bug and calling it a day.

We're using this as an opportunity to review all of our legacy code.

This is a task that would have been quite difficult to accomplish without AI.

And on to the next-generation visual inspection OS

What's interesting is that the more you examine past code, the clearer the vision of the software you should build next becomes.

FlexInspector from 20 years ago.

The FIS-100/200 from 10 years ago.

And the next-generation visual inspection OS we’re about to develop.

These are no longer separate projects.

Analyzing legacy software using AI.

We will summarize the problems and design challenges identified there.

I'm thinking about why it was designed that way.

We will then incorporate those findings into the design specifications for the next-generation system.

In other words,

We will transform our software assets accumulated over the past 20 years into design assets for the next 10 years.

That's how the work is going.

What Holds Value in the Age of AI

I believe that AI will definitely reduce the cost of writing code.

That’s why what matters going forward may not just be “how much code you have.”

While writing that code,

What went wrong?

Why was it designed that way?

What kind of problems occurred on site?

How did you fix it?

It's the accumulation of those experiences.

AI looks set to become a very powerful tool for unearthing that information.

Code written more than 20 years ago is regaining value thanks to AI.

I think this is a pretty interesting development for a company that has been developing software for many years.

That said, there is one problem if you start doing that in earnest.

6,000 AI credits isn't nearly enough.