lagangaactiva

Inspiration

At first, we wanted to build a plugin to help developers handle log failures more easily. But after some research, we realized that similar solutions already existed. Even though we had already spent a lot of time on that idea, we decided to step back and rethink.

Then, during a discussion, someone mentioned that we would need to write tests for our project, and we literally heard people complaining about it. That moment really stayed with us.

As first-year students and Java developers, we already knew how painful and time-consuming writing tests can be. That’s when the idea clicked: instead of building something that already exists, why not solve a problem that every developer actually struggles with?

What it does

We built an IntelliJ plugin that automatically generates complete Spring Boot integration tests using AI, all in one right-click.

Instead of spending 30–60 minutes writing tests manually, developers can now generate them in about 10 seconds. The plugin creates real integration tests that run the full application, test real HTTP endpoints, and interact with the database.

It also improves over time by learning from previously generated tests.

How we built it

We built the plugin using the IntelliJ Platform SDK and used PSI (Program Structure Interface) to analyze Java code and detect Spring Boot controllers.

We integrated AI (GPT-4o) to generate the test code based on the controller. The plugin sends the code to the AI, receives a complete test class, and automatically adds it to the correct place in the project.

We also implemented a self-healing system that retries if the generated code fails.

For storage and learning, we used PostgreSQL to save successful tests, allowing the system to improve over time. Since we had never built a plugin before, this was a completely new experience for us.

Challenges we ran into

One of the biggest challenges was changing our initial idea after already investing time in it. It wasn’t easy to let go and start over.

We also had to learn many new technologies quickly, including how to build IntelliJ plugins and how to integrate AI properly.

Another challenge was handling cases where the AI generated incorrect code. That’s why we built the self-healing mechanism to automatically fix errors.

Accomplishments that we're proud of

We’re proud that we built a fully working IntelliJ plugin from scratch, something none of us had done before.

We also successfully created a system that generates real integration tests, which is something most existing tools don’t do.

Finally, we’re proud that our plugin doesn’t just generate code, it learns and improves over time using PostgreSQL.

What we learned

We learned how to adapt when an idea doesn’t work and how important it is to focus on real problems.

We also learned how to work with new tools and technologies, like PostgreSQL and the IntelliJ Platform, even as first year students.

Most importantly, we learned how to turn a frustrating developer experience into a practical solution.

What's next for lagangaactiva

Three things. First, use past tests in the PostgreSQL database as examples in the prompt , making each generation smarter than the last. Second, a team dashboard showing test coverage across all controllers. Third, support for more frameworks beyond Spring Boot, like Quarkus and Micronaut