PS Logo

Are My Plugins Vibe Coded? No. Here's How I Build Them.

I use AI every day when I build plugins. I don't vibe code them. Those are two very different things, and you can't tell them apart from a screenshot. What vibe coding is, what I let AI write and what I shape myself, what my plugins are built on, and how you can check any plugin yourself.

By |
Phil Speiser

Are my plugins vibe coded?

Fair question. In 2026, anyone can type a prompt and get a plugin back. I bought a bunch of those and measured them. It wasn't pretty.

So, the short answer: no.

I do use AI. Every day. But using AI and vibe coding are two very different things, and the difference matters to me.

What Is Vibe Coding?

Vibe coding means describing what you want to an AI, letting it write the whole program, and accepting the result without reading the code.

The term was coined in February 2025. In the words of the AI researcher who came up with it, you "fully give in to the vibes" and "forget that the code even exists."

For a plugin, that looks like this: one prompt, a few minutes, a finished download. Nobody designed it. Nobody read it. Nobody knows what happens to it in a real session.

I don't hate vibe coding. Lower barriers mean more people with great ideas can build things. But audio runs in real time, so careless code gets unstable fast, and careless processing ends up in your record.

What Is AI-Assisted Development?

AI-assisted development means a person designs the software, decides how it should work, lets AI write the routine parts, tests the result, and answers for it.

That's how I work.

AI writes the code where it wouldn't matter whether I wrote it or anyone else did.

That leaves me free for what does matter: shaping the product, and the creative work. I make the engineering decisions. And I take responsibility for what ships.

That's quite different from prompting for a finished plugin and accepting whatever comes back.

Vibe codingHow I build
Who shapes the productThe AI, from a promptMe
What the AI writesEverythingThe parts where it doesn't matter who wrote them
Who reads the codeNobodyI review it before it ships
What it's built onUsually stock JUCE effects behind stock JUCE controlsMy own UI and DSP libraries, with JUCE as the glue to your DAW
How it's tested"Sounds fine in the demo"Simulations, automated tests, measurements, then my ears
When it's doneWhen the first version runsAfter months of fine-tuning, when it feels right in real music
When it breaksPrompt again and hopeI know where to look, and I fix it
Who answers for itHard to sayMe

I Built Plugins Before AI Could Code

I've been developing audio plugins since well before AI coding tools became practical.

I started with zero coding skills. I couldn't find people who shared the vision, so I learned to build my tools myself. That year of 12-hour days was probably the toughest of my life.

  • March 2022: my first plugin, THE_SAMPLER.
  • November 2022: ChatGPT launches, eight months later.
  • End of 2024: more than 20 plugins released.
  • February 2025: the term "vibe coding" is coined.

By the time vibe coding had a name, I'd spent years learning what makes a plugin hold up in a real session. Mostly by getting it wrong first and fixing it.

What Are My Plugins Built On?

In November 2025 I started again with a new foundation. Every plugin I've released since then is built on it, in C++.

Like most of the plugin industry, I use JUCE. It's the well-proven glue between your computer's audio and your DAW: the plugin formats (VST3, AU and AAX), the window, the conversation with the host. It also brings basic maths building blocks, like the one that turns sound into a spectrum. I use those where they're proven, and build my own where they aren't good enough.

But JUCE also ships ready-made effects and ready-made controls.

And that's what a typical vibe-coded plugin is: stock JUCE effects behind stock JUCE knobs, with a new name on top.

None of JUCE's ready-made effects is in my plugins. Not its compressor, not its limiter, not its reverb. What you see and what you hear comes from two libraries of my own:

  • My own UI library. More than 100 components: every knob, meter, spectrum display, step grid and browser you see in my plugins, designed and drawn my way. Tooltips in five languages and windows you can resize come with it.
  • My own DSP library. Everything that makes the sound: the compressor, the EQ, the clipper, reverbs, filters, samplers and many more. Fix something once, and every plugin that uses it gets better.

This is why my plugins look related. They share one library and one set of rules. That's the opposite of a plugin somebody prompted into existence last weekend.

Does AI Write My Code?

A lot of the code in a plugin has a right answer. Saving your settings. Connecting a knob to the sound. Drawing a menu. Translating a tooltip.

It works or it doesn't, and a test can tell. It wouldn't matter whether I wrote that code or anyone else did.

So AI writes it.

Then there's the part with no right answer. What should this plugin do? How should a compressor react to a vocal? What happens when you turn this knob? When is it good enough?

That's the product. And that's where my time goes now.

It's the same deal I build into my plugins: the technical detour gets handled, and the creative decisions stay with a human.

Here's how that works day to day:

  • AI works inside my libraries, by my rules. A written rulebook sits next to the code. One of the rules: on the part of a plugin that makes sound, nothing is allowed to make your audio wait. That's exactly where careless plugins start to crackle.
  • I review the work, and I listen. Nothing ships because a test turned green. It ships when I've heard it and I'm happy with it.
  • I answer for it. There's no big team here, just me. When removing THE_STRIP 3 from a big session could freeze your DAW, the fix came on launch day.

Typing code was never the hard part. Knowing what to build, and knowing when it's good enough, is.

The Prototype Is Fast. The Plugin Takes Months.

I build every plugin in my own development framework. With it, a first prototype is ready blazingly fast.

That's where a vibe-coded plugin stops. It's where mine starts.

Then come months of fine-tuning every single detail. Testing. Making music with it. Changing things because they don't feel right yet. Again and again, until it's done.

No test can tell me when a plugin feels right. Only making music with it can.

Where AI Changes Everything: Testing

This is the part I'm most excited about.

I use AI to build extremely powerful testing models. Simulations, measurements and modelling that push my plugins much further than I could by hand.

  • A virtual producer makes a beat in the real THE_PATTERN 2, clicking the way you would. It counts the clicks, flags the ones that did nothing, and finds every control without a tooltip.
  • A simulator runs whole sessions of real THE_STRIP 3 strips, connected the way they connect in your DAW, and checks what they do together.
  • Your saved sessions stay safe. Change THE_COMPRESSOR 2's engine, and 68 setups are rendered and compared with the released version, bit for bit. A session you saved last month has to sound the same next month.
  • Models get tested, not trusted. One early tempo model for THE_PATTERN 2 looked perfect. It had memorised the test. It was caught and rebuilt.
  • Blind listening has the last word. Two "smarter" versions of THE_PATTERN 2's sound matching lost or tied against the simpler one in blind listening. They were removed.

This is how one person can push boundaries. Standard oversampling left digital junk at -56 dB in my measurements, no matter how high I set it. So I built my own oversampling for THE_CLIPPER. There, that junk sits below -160 dB, where nobody will ever hear it.

I didn't get there by hoping. I got there by measuring, changing, and measuring again.

The machine measures. My ears decide.

Can You Tell if a Plugin Is Vibe Coded by Looking at It?

No.

The visual design alone doesn't reveal how the software was engineered. A clean interface can sit on careless code. A rough one can sit on excellent code.

What shows the engineering is how a plugin behaves. Does the EQ boost the frequency you dialed in? At every sample rate? Is it still stable after three hours in a full session?

You don't have to take my word for any of this. Measure it.

I turned my internal test suite into a free app: THE_LAB. Load any plugin, press CHECKUP, and read the verdict in plain words. Mine included.

And I publish what I measure, including the parts I didn't love: THE_STRIP 3 and THE_SMOOTHER 2's KEY mode.

Why This Matters to Me

AI is the best thing that has happened to the way I build plugins. It takes the routine code off my desk, and it lets one person test like a big team.

But it doesn't decide what a plugin should do. It doesn't hear whether a compressor feels right on a vocal. And it doesn't answer your email when something goes wrong.

That's me.

So no, my plugins aren't vibe coded. They're built by a producer who learned to code the hard way, on libraries I built myself, with AI writing the code anyone could write, so I can spend my time on the part that makes them mine.

Don't trust that because I said it. Open THE_LAB and check.

I can't wait to hear what you make.

FAQ

Are Phil Speiser plugins vibe coded?

No. Vibe coding means prompting an AI for a finished program and accepting the result without reading the code. I've been building plugins since before AI coding tools were practical: my first plugin came out in March 2022, eight months before ChatGPT. Every plugin I've released since November 2025 is built on my own C++ UI library and my own C++ DSP library. I use AI for the parts of the code where it doesn't matter who wrote them. I shape the product, make the engineering decisions, and take responsibility for what ships.

Does Phil Speiser use AI to build his plugins?

Yes, every day. AI writes the parts of the code where it wouldn't matter whether I wrote them or anyone else did. That frees me to focus on shaping the product and on the creative work: what a plugin does, how it sounds and how it feels. Where AI changes the most for me is testing: simulations, measurements and test models at a scale one person could never run by hand.

What is the difference between vibe coding and AI-assisted development?

Who shapes the product. In vibe coding, you describe what you want, the AI writes the whole program, and you accept the result without reading the code. In AI-assisted development, a person designs the software, decides how it should work and sound, lets AI write the routine parts, tests the result, and is responsible for it. I work the second way.

Does AI write the code in Phil Speiser plugins?

It writes the parts where it wouldn't matter whether I wrote them or anyone else did: saving your settings, connecting a control to the sound, a menu, a translated tooltip. That code has a right answer, and a test can check it. What a plugin does, how it sounds and how it feels has no right answer. That's the creative work, and it's mine. I make the engineering decisions and take responsibility for what ships.

How long does it take Phil Speiser to build a plugin?

A first prototype is ready very fast, because I build every plugin in my own development framework. That's where a vibe-coded plugin stops, and where mine starts. Then come months of fine-tuning every single detail: testing, making music with it, and changing things because they don't feel right yet, until it's done.

What are Phil Speiser plugins built with?

Every plugin I've released since November 2025 is written in C++ on a foundation I built myself: my own UI library with more than 100 components, and my own DSP library with the compressor, EQ, clipper, reverbs, filters, samplers and everything else that makes the sound. Underneath sits JUCE, the framework most of the plugin industry uses, as the proven glue between the computer's audio and the DAW (VST3, AU, AAX).

Do Phil Speiser plugins use JUCE?

Yes, the way most of the plugin industry does: as the well-proven glue between the computer's audio and the DAW. JUCE handles the plugin formats (VST3, AU, AAX), the window and the conversation with the host, and I use some of its basic maths building blocks where they're proven and build my own where they aren't good enough. None of JUCE's ready-made effects is in my plugins. The compressor, the EQ, the clipper and the reverbs come from my own C++ DSP library, and every control you see comes from my own C++ UI library.

What does a typical vibe-coded plugin look like under the hood?

Usually stock JUCE effects behind stock JUCE controls, with a new name on top. JUCE is a great framework and ships ready-made effects and knobs, so an AI can assemble them into something that looks like a plugin in minutes. What's missing is the engineering around them: in my tests, vibe-coded plugins boosted the wrong frequency, added junk nobody asked for and leaked memory until the session crashed.

Can you tell from a plugin's design whether it was vibe coded?

No. The visual design alone doesn't reveal how the software was engineered. A clean interface can sit on careless code, and a rough one on excellent code. My plugins share one look because they share one UI library. What shows the engineering is how a plugin behaves: whether it does what the controls say, at every sample rate, in a real session.

How can I check whether a plugin is well engineered?

Measure it. THE_LAB is my free test bench for macOS and Windows. Load any plugin, press CHECKUP, and it tells you in plain words whether the plugin does its job, adds anything you didn't ask for, is honest with your DAW and survives a real session. It works on plugins from any developer, including mine.

Did Phil Speiser make plugins before AI coding tools existed?

Yes. I started with zero coding skills and taught myself to build plugins. My first one, THE_SAMPLER, came out in March 2022. ChatGPT launched in November 2022, and the term 'vibe coding' was coined in February 2025. By the end of 2024 I had already released more than 20 plugins.

Who is responsible when a Phil Speiser plugin has a bug?

I am. There's no big team here, just me. I make the engineering decisions, so when something breaks I know where to look, and I fix it. When removing THE_STRIP 3 from a big session could freeze a DAW, the fix came on launch day. Support comes straight to me at philspeiser.com/support.