I Built Something Good With AI. Now Some Developer Communities Don't Want to See It.

I recently tried to share an open-source project I've been working on called Open Vectorizer.

It's a raster-to-SVG vectorization engine written in Rust. It runs locally, compiles to WebAssembly, has a reproducible benchmark suite, and competes surprisingly well with established tools like Potrace and VTracer.

I wanted people to see it.

More importantly, I wanted contributors.

That's where things got weird.

First, Hacker News

Open Vectorizer felt like a natural fit for Show HN.

It's open source. It's technical. There's an interesting algorithm behind it. There are benchmarks people can reproduce and argue about, which I'm told is approximately 73% of Hacker News' renewable energy supply.

Except I couldn't submit a Show HN.

Hacker News is temporarily restricting Show HN submissions from newer users because of a large influx of people unfamiliar with the community.

Fair enough.

Annoying, but understandable.

So I tried Reddit.

Then r/rust

Open Vectorizer is written in Rust, so r/rust seemed like an even more obvious place to share it.

The post was automatically removed.

The subreddit now requires project submissions to certify that they do not contain significant AI-generated content.

And that's something I can't honestly certify.

Open Vectorizer has been developed with substantial AI assistance.

So I didn't repost it.

Then r/opensource

Surely an MIT-licensed project actively looking for contributors belongs in an open-source community.

Their rules include:

All AI-generated content is low-effort and ban worthy.

At this point I had to appreciate the situation.

I had an open-source project.

I wanted humans to contribute to it.

And some of the communities containing exactly those humans didn't want me to tell them about it because machines had helped write it.

Here's the problem

I actually understand why these rules exist.

AI has made it incredibly cheap to produce software-shaped objects.

You can ask an agent to build a database, publish 20,000 lines to GitHub an hour later, write a triumphant launch post and have absolutely no idea whether the thing works.

Developer communities are being flooded with this stuff.

That's a real problem.

But I think we're using the wrong filter.

"Was AI used to write this?" is increasingly becoming a poor proxy for "Is this low-effort garbage?"

Those are not the same question.

What does "AI-generated" even mean anymore?

Imagine five developers.

Developer A writes everything manually but uses IDE autocomplete.

Developer B uses GitHub Copilot for completions.

Developer C asks an agent to implement individual functions from detailed specifications.

Developer D designs the architecture, writes tests, evaluates results and delegates much of the implementation to coding agents.

Developer E types:

make me a vectorizer

They publish whatever comes back.

Which projects are AI-generated?

There's an obvious difference between D and E.

But drawing the line based on how many characters were physically typed by a human doesn't capture that difference particularly well.

And that distinction is only going to become harder to make.

Open Vectorizer is a useful example

The first version of Open Vectorizer wasn't good enough.

It followed a relatively conventional vectorization pipeline: find pixel boundaries, simplify them and fit curves.

The results weren't terrible.

They also weren't good.

Circles weren't quite circular. Sharp geometry got damaged. Small raster imperfections became vector imperfections.

Eventually I stopped working on it.

Later, I revisited the problem with AI assistance.

We investigated whether machine learning was the answer. We discussed training a small vision model on synthetic SVG-to-PNG data.

It probably could have worked.

I decided against it.

Instead, the underlying deterministic algorithm was redesigned.

The important realization was that anti-aliased pixels aren't simply noise to discard. They contain information about how much of the original geometry covered each pixel.

Open Vectorizer now uses that information to reconstruct boundaries at sub-pixel precision. It detects corners and geometric primitives, generates candidate representations, rasterizes those candidates back into pixels and measures how accurately they reproduce the source.

That's how it can take a rasterized circle and produce an actual SVG circle instead of a vaguely circular collection of Bézier points.

AI helped develop that system.

The vectorizer itself doesn't use AI.

So is Open Vectorizer AI-generated software?

Apparently, yes.

But that description tells you remarkably little about its quality.

Then the AI found a bug that made our benchmark look better

This happened while preparing a visual comparison for the project.

The benchmark compares Open Vectorizer against Potrace and VTracer. One metric is the number of vector nodes required to represent the result.

While regenerating the comparison, the coding agent discovered that our node-counting implementation was wrong.

Different SVG generators close paths differently.

Our benchmark accidentally gave Open Vectorizer one fewer node than it deserved on closed paths while charging Potrace an extra node.

That's quite an inconvenient bug when you're trying to demonstrate that your software produces simpler geometry.

So we fixed it.

We regenerated the tables.

Open Vectorizer's numbers got worse.

VTracer went from beating it on node count in 2 of 17 cases to beating it in 5.

We documented why several of those cases occur and added the underlying inefficiency to the project's TODO list.

The accuracy results, incidentally, still reproduced exactly.

That's the development process I want from software, regardless of whether the person finding the bug contains carbon.

Judge the artifact

Maybe the questions we should be asking about AI-assisted open-source projects are different.

Instead of:

Did AI write significant portions of this?

Ask:

• Can the maintainer explain the architecture?
• Is the source available?
• Are there meaningful tests?
• Can its claims be independently reproduced?
• Are benchmarks transparent?
• Are weaknesses disclosed?
• Does the maintainer review and take responsibility for changes?
• Are bug reports actually understood and fixed?
• Is the project maintained after the initial generation?
• Can contributors challenge technical decisions?

Those questions tell me considerably more about whether I want to use or contribute to a project.

And they work equally well for human-written software.

Humans, inconveniently, have been producing terrible code since decades before ChatGPT arrived.

AI assistance doesn't remove responsibility

This isn't an argument that AI-generated code is automatically good.

Quite the opposite.

If I use a coding agent and it introduces a vulnerability, that's my problem.

If it produces an algorithm I don't understand, I shouldn't ship it.

If it invents benchmark results, I am responsible for publishing false information.

Using AI shouldn't reduce the standard.

It should increase the burden on the maintainer to demonstrate that the result actually works.

That's why reproducibility matters.

That's why tests matter.

That's why admitting where your competitor beats you matters.

"I used AI" isn't a defense against bad engineering.

But neither should it automatically invalidate good engineering.

The irony for open source

The strangest part of this experience is that I specifically want Open Vectorizer to become less dependent on me and my coding agents.

I want someone who knows computational geometry to look at the curve fitting and tell me it's stupid.

I want a Rust developer to make the coverage decomposition faster.

I want someone who understands SVG internals better than I do to improve stroke reconstruction.

I want someone to submit an algorithm I hadn't considered.

In other words:

I want human contributors.

But to find them, I need to be able to show humans the project.

Rejecting AI-assisted projects categorically creates a strange loop where projects developed by individuals with AI assistance have fewer opportunities to evolve into genuinely collaborative open-source projects.

That seems counterproductive.

We need a better distinction

I don't think developer communities should simply throw their doors open to unlimited AI-generated project spam.

Nobody wants that.

Moderation is necessary.

But perhaps the distinction shouldn't be:

Human-generated vs AI-generated.

Maybe it should increasingly be:

Maintained engineering vs generated slop.

Did somebody actually make decisions?

Did they evaluate the output?

Did they understand it?

Did they test it?

Will they maintain it?

Can they defend its claims?

Are they accountable for what they published?

Those are harder questions to moderate.

Unfortunately, they're also the questions that matter.

Because AI-assisted development isn't going away.

And as the tools improve, determining whether a particular function was typed by a human, generated by Copilot, implemented by Claude from a specification, or refactored by an autonomous agent will become increasingly meaningless.

The software still has to work.

Someone still has to be responsible for it.

And if it does something interesting, I'd still like to be allowed to tell other developers about it.

(AI was used to write this article)