Here’s How I broke Gemini 3 AI guardrails to reverse-engineer a highly advance proprietary Japanese imaging software

To be honest, my intentions were not right when I broke Gemini 3.1 Pro but later on, it became a research experiment for me.

Six months back, I started this when Gemini 3.1 Pro was released (around February) and honestly, I was not sure whether it works or not.

The experiment began in late Q4 2025, when I got access to highly advance proprietary Japanese imaging software from Dark Web. The software took 15 years to develop by a Japanese firm, but the software was in .exe, .dll and lot of other formats.

This imaging software is a niche product and have so much demand but it is very expensive.

I somewhat have basic knowledge about Ghidra, ASM and some basic RE tools, but not so advanced.

I got started with Ghidra and tried to find patterns, functions, and logic to understand how this software actually worked? I tried to understand assembly code and asking myself, “What the hell is going on?”.

I removed the security from the software.

I created a specialized Gem inside Gemini so that it would focus on reverse engineering. I used guard break prompts and played with the context window so that Gemini became a little more uncensored.

This is where the experiment started getting really interesting. I noticed that Gemini was not giving me the exact same answer every time. Even small changes in how I structured the context, wrote the instructions, or presented the information could have a big impact on how the model responded.

Sometimes it refused to help. Sometimes it gave me a partial answer. Sometime it’s say I can’t assist with that. And sometimes, after changing the context and approach, it started giving me much more technical details. That was the point where I became more interested in the AI and wondering whether Gemini behaviour itself could be reverse engineered?

While I was reverse engineering the software, I was also experimenting with Gemini in parallel trying to understand how its behaviour changed with different contexts, instructions, and approaches and TBH Gemini helps me a lot.

So, in a way, I was running two experiments at the same time: reverse engineering the software and trying to understand the behaviour of the AI helping me do it.

I was not training Gemini or changing its actual model weights. I was trying to influence its behaviour through the interface and context available to me.

And that experiment taught me something important. Guardrails are not the same thing as the model’s underlying capabilities. A model can have the technical capability to reason about something while still configured not to provide certain types of assistance.

At the same time, I was going back and forth between Ghidra, assembly, decompiled code, the application’s behaviour, and Gemini’s explanations. A lot of the time Gemini was useful. A lot of the time it was also wrong. So I had to verify what it was telling me against the actual binary.

That my wrong intentions pushed me much deeper into reverse engineering than I originally expected.

I started understanding things that I had never worked with seriously before such as program structure, logical behaviour, functions, memory behaviour, C++, system design, and how different pieces of a large application interact with each other.

Eventually, I heavily modified the entire UI and theme of the software while keeping the backend algorithms same.

I also implemented my own security and licensing mechanisms that is designed by me to protect the software I had built (aka Reverse engineered software). The licensing or security layer combines multiple hardware identity checks, a secret salt (known only to me) , and additional verification logic that I deliberately won’t describe publicly.

After going through the software from .exe, .dll, and other formats, from decompiled code to a working recompiled implementation, I realised something else, that I’ve a chance to earn lot of money.

But I stopped.

Not because I couldn’t continue.

Because I started thinking about the ethics of what I was doing.

The software was not mine.

This software was the result of 15 years of development.

And having the technical ability to reverse engineer something doesn’t automatically give me the ethical right to use, distribute, or commercialise it.

So I ditched the project.

That was probably the most important lesson of the entire experiment.

I learned reverse engineering.

I learned more about assembly, Ghidra, C++, system design, software architecture, licensing, and security.

But I also learned about AI security.

I learned that guardrails can behave differently depending on context. I learned how important it is to separate model capability from model behaviour.

And I learned something about myself as a researcher:

“Just because you can break something doesn’t mean you should use what you broke.”

The experiment started with the wrong intentions.

But it ended up teaching me a lot about AI security, reverse engineering, and my own responsibilities as a researcher.

And honestly, walking away from a project can sometimes be a more important engineering decision than finishing it.

Sometimes the most important engineering decision is not:

“Can I finish this?”

It’s:

“Should I?”

Wrong Intention → Experiment → AI behaviour → Reverse engineering → Building → Ethical realization → Walking away → Lessons.