DEV Community: Yancan Chen

I stopped blindly trusting AI-generated code's Big-O — here's how

Yancan Chen — Thu, 25 Jun 2026 03:02:02 +0000

Last year I shipped a feature with a search function that Claude wrote for me. It worked perfectly in staging. In production, with real data, it turned our 300ms page into a 12-second timeout.

The function was O(n²). I had accepted it without checking. Claude never mentioned it was quadratic.

The problem isn't that AI writes bad code

Modern AI coding assistants write code that works. That's actually the problem. When something runs without errors, your brain marks it as "done" — even if it's secretly going to fall apart at scale.

AI assistants are trained to produce code that satisfies your immediate request. They're not trained to proactively say "by the way, this is O(n²) and there's an O(n log n) version." That would require second-guessing your requirements, which most of the time you don't want.

So you get working code, no complexity disclosure, and a hidden assumption that you'll catch the performance issues yourself. Most of us don't.

Why the usual fixes don't stick

I've tried a few approaches:

"Just ask Claude/ChatGPT about complexity after." Works, but only if you remember to do it, only for code you're actively suspicious of. In practice I forget for 80% of snippets I accept.

"Review every snippet manually." I'm using AI to go faster. Manually reviewing every line for Big-O is slower than writing it myself.

"Run benchmarks." Great for functions you already know are suspect. Doesn't help with the ones you don't know to benchmark.

The issue is the friction. The check has to happen at the point of acceptance, not as a separate later step.

What I built

I made a Chrome extension — AI Code Explainer — that runs the analysis at exactly the moment you're reading a code block.

Hover over any code block on ChatGPT, Claude, or GitHub for 1.5 seconds. A panel drops in below the code showing:

Algorithm name (e.g., "Binary search", "Depth-first traversal", "Sliding window")
Time complexity (e.g., O(n log n))
Space complexity (e.g., O(1) auxiliary)
Alternative — if there's a meaningfully faster approach, it names it and sketches the idea

You bring your own API key (Claude, GPT-4o mini, Gemini 2.0 Flash, Groq, or DeepSeek — Groq's free tier works with no credit card). Nothing routes through a server I run. Free tier is 10 analyses/day; Pro is $5 one-time, no subscription.

The hover-trigger was a deliberate choice. A button you have to click is something you skip. A panel that appears while you're already reading the code intercepts you before you've scrolled away.

The checklist I use now

Even if you don't use the extension, here's what I check on every AI-generated snippet before accepting it:

What's the input size in production? If the function touches a list, how long is that list at max load? Quadratic is fine for 100 items. Catastrophic for 100,000.
Does it nest loops? Nested loops over the same collection are the most common source of accidental O(n²). Count them.
Is there a sort hiding inside a loop? list.sort() inside a for loop = O(n² log n). AI does this more often than you'd expect.
Does it rebuild a data structure per iteration? Converting a list to a set inside a loop is O(n) work per iteration. Should be done once before the loop.
Ask for the alternative. If you're not confident about complexity, ask the AI: "Is there a more efficient version of this? What would the time complexity be?" Most of the time it knows — it just didn't offer.

The extension automates steps 1-4 for me. Step 5 still needs a human question, but it at least gives you the vocabulary to ask it well.

One example that changed how I use AI for code

I was using Claude to write a deduplication function. It gave me something that iterated over a list and checked each element against a running list of seen items. Readable, obvious, correct.

The extension flagged it as O(n²) and suggested a set-based approach — iterate once, check membership in O(1), total O(n). Two-line change. Same logic, 1000x faster on large inputs.

I knew the set trick. I just hadn't thought to apply it because I was reading Claude's code, not writing my own. The check happened at the wrong time.

That's the whole product: make the check happen at the right time.

AI Code Explainer — Chrome extension, works on ChatGPT / Claude / GitHub, BYOK, $5 one-time.
Install: https://chromewebstore.google.com/detail/lcfaenfeajomoombkjcoelpjmmhknlid

Token Watcher – see exactly what your Claude/ChatGPT conversations cost

Yancan Chen — Thu, 18 Jun 2026 14:49:43 +0000

Hi, I built this because I kept wondering "how much did that conversation
actually cost me" when using Claude.ai / ChatGPT in the browser (not the API).

Token Watcher intercepts the streaming responses client-side to read the
input/output/cache token counts and computes cost against current Anthropic/
OpenAI pricing — no API key, nothing leaves your browser.

It also tracks MCP (Model Context Protocol) call health — total calls and
error rate — which I haven't seen any other tool surface for the Claude.ai
web UI specifically.

Free tier: 7-day history, real-time cost + model breakdown, MCP monitoring.
Pro ($9 one-time): 30-day history + CSV export.

Happy to answer questions about how the token interception works or take
feedback on what else would be useful to track.

Why I Built a Tool to Diagnose Chrome Extension Rejections

Yancan Chen — Wed, 17 Jun 2026 09:01:56 +0000

I've been building indie software tools for the past year. Most of them are Chrome extensions.

Last month, I was scrolling through Reddit's r/ChromeExtensions when I saw a post that stuck with me:

"My extension got rejected again. Google just says 'violates policies.' I have no idea what's wrong. Should I just give up?"

The replies were all the same: "Check your permissions. Add a privacy policy. Try again."

But here's what bothered me: nobody really knew what the actual problem was. Everyone was just guessing.

That's when I realized — this isn't a skill issue. It's an information problem.

The Developer's Nightmare

Think about it from a developer's perspective:

You spend weeks building a Chrome extension. You think it's solid. You submit it to Google Web Store.

48 hours later: Rejected.

Google's email: "Your extension violates Chrome Web Store policies. Please review our policies and resubmit."

That's it. No specifics. No "it's the webRequest permission" or "your description is misleading." Just... rejected.

So what do you do?

Read 50 pages of Chrome Web Store policy documentation (which one applies?)
Check Reddit threads from 2021 (still relevant?)
Delete random permissions (will this actually fix it?)
Resubmit and hope (probability of passing: unknown)

This cycle can repeat 3-5 times. Each time, you lose:

48 hours waiting
Opportunity cost (could've been building something else)
Confidence (is my code just bad?)

And here's the kicker: there's no appeal process. You can't argue with Google. You just... try again.

Why This Matters (Especially to Indies)

For enterprises, this is an annoyance. They have DevOps teams and compliance experts.

For indie developers like me, this is a real blocker.

Your Chrome extension is distribution channel + credibility + revenue. Without it, you're stuck.

I started tracking rejections in the community. The numbers surprised me:

40% of first-time rejections are due to "overly broad permissions"
25% are missing privacy policy or misleading descriptions
20% are due to unclear functionality
15% are edge cases or genuinely confused rejections

The first three categories? They're 100% preventable if developers knew exactly what Google was looking for.

The Idea

I thought: What if there was a tool that could diagnose rejection reasons in seconds?

A tool that:

Takes Google's vague rejection email
Analyzes your manifest.json and extension description
Tells you exactly which policy you violated and why
Suggests specific fixes with code examples
Generates a professional appeal letter

Not a guessing game. Actual diagnosis.

Building Chrome Extension Doctor

I spent the last 3 weeks building exactly that.

Here's what it does:

Step 1: Upload Your Info

Paste Google's rejection reason
Paste your manifest.json
Briefly describe your extension

Step 2: AI Diagnosis

Analyzes against Chrome Web Store policies
Identifies high/medium/low risk issues
Explains why each one is a problem
Suggests specific fixes

Step 3: Generate Appeal

Creates a professional appeal letter
References specific Google policies
Lists all your improvements
Ready to send to Google

The whole process takes 30 seconds instead of 3 hours of researching.

Why I'm Sharing This

I could've just kept this as a side project. But I realized: this is exactly the kind of tool indie developers need.

It solves:

✅ Information asymmetry (Google doesn't explain rejections)
✅ Time waste (hours of research → 30 seconds)
✅ Emotional frustration (someone actually helps)
✅ Increased success rate (you fix the real problem, not guessed problems)

What's Next

I'm launching Chrome Extension Doctor this week.

It's built on:

Frontend: Pure HTML/CSS/JS (no framework bloat)
Backend: Cloudflare Workers + Claude API
How to use: Free trial included, no credit card required

The tool is live and ready to try. The first 50 users will help me refine it. Your feedback will shape what comes next.

The Bigger Picture

This is part of a larger experiment I'm running: solving specific pain points for indie developers.

Each tool is:

Tiny in scope (solves ONE problem)
Fast to build (weeks, not months)
Validated by real users
Actually profitable

Chrome Extension Doctor is #3 in this series. #1 and #2 are already making money.

If this works, I'll build more tools in this vein. Because I believe:

The best indie products aren't trying to replace enterprise software. They're solving the micro-problems that affect thousands of solo developers.

For You

If you've ever built a Chrome extension, you know this pain
If you've been rejected, you know it could've been easier
If you believe in helping indie developers, let's chat

Have you been rejected by Google's extension store? What was your experience?

Comment below. I'm reading every reply.

Next week, I'll write a deeper dive into how the tool works and share a live demo.

P.S. — If you're an indie dev building your own stuff, I'd love to hear what other tools would make your life easier. Reply in the comments.