How I Shipped My First Chrome Extension in 3 Days with ChatGPT (and 20 Years of Dev Experience)

I just launched my first Chrome extension — built it in 3 days with ChatGPT (and 20 years of dev intuition).
Sharing what I learned: building fast, avoiding overthinking code, and shipping something actually useful.
Would love your feedback!

I have 20 years of dev experience, but when it comes to JavaScript and Chrome extensions, I was basically a noob.
Still, with ChatGPT’s help, I shipped my first Chrome extension in 3 days, something that would have taken me a month or more otherwise.

The extension’s goal is to promote my primary SEO tool while providing real value for free. It scans any website’s content and suggests internal links. When you click a suggestion, it shows a live preview by scrolling to the anchor text, highlighted in green, in a side panel.

The extension has just been released, it's called Internal Link Builder, any feedback is very welcome!

It actually started earlier with a PHP prototype

Before even touching JavaScript, I wanted to test if the concept worked:
Can I find good internal link suggestions with the approach I had in mind? Can I create something useful?

Since I'm more comfortable with PHP, I built a prototype in PHP — again, entirely with ChatGPT.
I didn’t write a single line of code manually. I described what I wanted, refined the prompts, and in about 4 hours, had a working prototype that:

• Parsed a sitemap.
• Crawled pages.
• Extracted the main content.
• Matched relevant keywords and suggested internal links.

The prototype immediately showed the idea had value. Playing with it even gave me new ideas for better parsing and smarter matching, which I iterated on quickly.

This early prototype phase was crucial:

• It proved the concept was worth building.
• It allowed me to refine the logic before worrying about Chrome extension specifics.
• It gave me confidence that the core value was there.

When it was time to start the real extension, I simply asked ChatGPT to translate the PHP code into JavaScript.
Surprisingly, this worked really well. ChatGPT was able to produce a full set of helper functions for the core logic.

My goals for the extension project:

• Build something genuinely useful, fast, and bring a lot of value for free.
• Avoid trying to deeply understand the code as much as possible. Stay high-level unless something breaks badly.
• Use the speed of prototyping to go beyond a basic MVP and actually ship a polished, fully-featured product.

The first Chrome extension version took me about 4 hours.

With the JavaScript version of the core logic ready, I hacked together the MVP with ChatGPT guiding me through Chrome’s APIs.
The UI was a popup showing a list of link suggestions.
It technically worked — but using it made me realize quickly it wasn't good enough. Popups are too cramped. Scrolling is clunky. It didn’t feel natural or user-friendly at all.

This led to V2

I decided to rethink the UX completely. Instead of a popup, I moved everything into a full-height side panel that opens alongside the page.
While exploring this, I also had a new idea: what if, instead of showing a small snippet of text, I actually previewed the real page, scrolled to the anchor text, and highlighted it?

That small change completely transformed the feel of the product.
It turned the extension from a simple suggestion tool into something visual, interactive, and much more engaging.

Technical struggles along the way:

Problem 1
When I asked ChatGPT how to implement the preview, it first suggested injecting an iframe into the current page to show the suggestions.
At first glance, it sounded reasonable — but it caused a lot of problems:

• Two scrollbars fighting each other.
• Weird flashes when loading the iframe.

After many frustrating back-and-forths with ChatGPT (where it kept suggesting minor tweaks to the same broken approach), I realized: time to flip the logic.

Instead of injecting an iframe into the page, the extension itself loads a clean page, and then displays the target page inside an iframe for previewing anchors. That change solved all of the visual issues.

Key lesson
If ChatGPT keeps suggesting minor variations of a failing solution, it’s a clear signal to change the approach, not just tweak the symptoms.

Problem 2:
I often had to re-explain or paste code again because ChatGPT would lose track of the architecture and previous decisions after a while.
Even when it seemed to understand, it would later suggest code that conflicted with earlier choices.

Key lesson:
ChatGPT moves fast but forgets. Be ready to reintroduce context often and keep your own clear picture of the architecture.

Problem 3:
At one point, ChatGPT suggested modifying the DOM while iterating through it using a TreeWalker.
The code seemed to work but actually caused some elements to be skipped or missed entirely.
Because the bug didn’t throw obvious errors and results looked “mostly correct,” it was tricky to spot.
It took experience to sense where the issue might be.

Key lesson:
AI-generated code can introduce subtle, non-obvious bugs. Your experience and critical thinking are essential to catch issues that aren’t immediately visible.

Problem 4:
When testing with several websites, I realized some forbid framing because of Content Security Policy (CSP) rules or X-Frame-Options headers.
ChatGPT didn’t warn me about these limitations, so the initial design worked fine on some sites but failed on others.

Key lesson:
ChatGPT won’t anticipate all real-world deployment issues. Wide testing is essential to catch problems that don’t show up in development.

Conclusion

ChatGPT was an incredible accelerator throughout this project. It provided fast solutions, unblocked problems quickly, and helped me prototype at a pace that would have been impossible alone.
But it also came with limitations: it was prone to mistakes, forgot previous context after long conversations, and occasionally introduced subtle bugs. I often had to reintroduce context or spot when something wasn’t working as expected.

ChatGPT amplified my productivity but didn’t replace the need for experience or sound engineering judgment.

Key takeaways:

• ChatGPT can massively speed you up, but it needs supervision and constant context management.
• Fast prototyping is key: Build something fast, play with it, discover what’s wrong, and improve it.
• 20 years of dev experience still mattered a lot — not to code faster, but to know when something was wrong even if nothing broke visibly.
• Validating the idea first (even with a quick PHP prototype) made everything that followed way faster and more focused.
• Sometimes the best way to fix a technical problem is to rethink the foundation, not tweak the symptoms.

You can grab the extension here: Internal Link Builder Chrome Extension

I would love any feedback if you try it out. I'm planning to keep improving it based on real-world usage!