DEV Community: Mike Chen

How I Built a Zero-Server Image Editor for 0¥/Month

Mike Chen — Mon, 29 Jun 2026 15:02:21 +0000

How I Built a Zero-Server Image Editor for 0¥/Month

I needed a simple tool to make stickers for WeChat. Existing online editors either upload your images to their servers (privacy nightmare), require registration, or watermark your output.

So I built 靓图 (LiangTu) — a pure client-side image editor that runs entirely in the browser. No server, no uploads, no account. Just drag, edit, download.

Here's the architecture.

The Stack: Zero Dependencies on the Server

Browser (100% of logic)
├── Canvas API       — rendering pipeline
├── gif.js           — GIF encoding (Web Workers)
├── FileReader API   — local image loading
└── No backend. None.

That's it. The entire app is a static HTML/CSS/JS page served by Nginx. No Node.js, no database, no API routes. The server's job is to ship bytes once and shut up.

What It Does

Three tools, one domain:

Tool	What it does	Tech
Sticker Editor	Add text layers, filters, watermarks, crop, compress	Canvas 2D
GIF Maker	Drag multiple images → reorder → adjust speed → export animated GIF	gif.js + Web Workers
Image Compressor	Quality slider with live preview	Canvas toDataURL

The sticker editor has 8 tools (crop, text with 14 Chinese fonts, background fill, flip, filters, adjustments, watermark, compress) plus a full layer system with z-ordering, rotation, and drag-to-reposition.

The Layer System

This was the hardest part. Each text element is an independent layer with:

layer = {
  text: '你好',
  x: canvasW / 2,
  y: canvasH - 40,
  fontSize: 24,
  fontFamily: 'Microsoft YaHei',
  textColor: '#FFFFFF',
  strokeColor: '#000000',
  strokeWidth: 2,
  rotation: 0
}

The render loop draws background → layers (top to bottom) → watermark. Hit testing for drag uses ctx.measureText() and rotation-aware bounding boxes. Selection shows a dashed outline with rotation handles.

GIF Encoding in the Browser

For the GIF maker, I use gif.js — a pure JavaScript GIF encoder that runs in Web Workers. Users drag in multiple images, reorder them, set the delay per frame, and hit export.

const gif = new GIF({
  workers: 2,
  quality: 10,
  width: maxWidth,
  height: maxHeight,
  workerScript: 'gif.worker.js'
});

frames.forEach((frame, i) => {
  gif.addFrame(canvas, { delay: speeds[i] * 100 });
});

gif.on('finished', blob => {
  const url = URL.createObjectURL(blob);
  // show preview + auto-download
});
gif.render();

The trick is normalizing all frames to the same dimensions (largest width × largest height), centering smaller images on a white background.

Why "100% Local" Matters

Every image stays in the browser. The <input type="file"> loads directly into a FileReader, then to an Image object, then to Canvas. The download is canvas.toBlob(). At no point does any pixel leave the user's machine.

For Chinese users especially, uploading photos to unknown servers is a hard no. Making "no upload" the core feature was the right call.

Cost: ~16¥/Month

Domain: liangtu.cc — 29¥/year
Server: Tencent Cloud Lighthouse (2 vCPU, 2GB RAM, 4Mbps) — 192¥/year
Total: ~16¥/month (~$2.20 USD)

No serverless functions, no CDN tiers, no database. A single Nginx server serving static files. The 4Mbps bandwidth handles ~3,000 page views/month with plenty of headroom.

The Traffic Problem

Here's where I'm honest: I built the product. The SEO is decent. But nobody's finding it (~5 real visitors/day).

If you've successfully grown a free tool site from zero, I'd love to hear how. Drop a comment or find me at github.com/fengloulai/liangtu.

Try it: liangtu.cc

Source: github.com/fengloulai/liangtu

fd vs find vs ripgrep: I Created 10,000 Files to Settle This Debate

Mike Chen — Fri, 29 May 2026 18:47:08 +0000

fd vs find vs ripgrep: I Created 10,000 Files to Settle This Debate

TL;DR: fd is ~2.5x faster than find for filename searches, rg demolishes grep by ~3x for content searches, and find + grep combined lose on every single benchmark I ran. But there's a catch: both fd and rg skip hidden files by default, which can bite you if you're not paying attention. Here are the receipts.

Why I Did This

Every time someone posts a shell one-liner using find on Reddit, there's always that guy in the comments: "jUsT uSe fD, iT's fAsTeR." Then someone else chimes in with "actually ripgrep can do that too."

I got tired of the anecdotes. I wanted numbers. Real ones. On real files. So I fired up WSL, generated 10,900 files across 1,506 directories (~143 MB of mixed content), and ran actual benchmarks with hyperfine. No synthetic microbenchmarks, no "I feel like X is faster" — just cold, hard terminal output.

Methodology

The Test Bed

I created a directory at /tmp/fd-benchmark containing:

Category	Count	Details
Plain text files	2,000	`file_*.txt` — 20 bytes each, contains "test content line N"
Binary files	2,000	`data_*.bin` — 15 bytes each
Log files	1,500	`match_*.log` — contains unique "match_this_test_N" strings
Config files	1,000	`nested_file_*.cfg`
Nested dir files	1,000	`level1_/level2/level3/deep_.txt` + `level1_/shallow_.txt`
Hidden root files	1,500	`.hidden_` + `.config_.yml`
Hidden dir files	500	`.hidden_dir/subdir/deep_hidden_*.txt`
Git objects	500	`.git/objects/obj_*`
Multi-ext source files	800	`src_*.{py,js,ts,rs,go,java,rb,php,cpp,h,css,html,json,xml,yaml,md}` (50 each)
Large binary files	100	`large_*.dat` — 1 MB each (random data)
Total	10,900

$ du -sh .
143M    .

$ find . -type f | wc -l
10900

$ find . -type d | wc -l
1506

Tools Tested

Tool	Version	What It Does
`find` (GNU)	4.9.0	The OG. Ships with every Linux distro.
`fd`	10.2.0	Rust-based `find` alternative. Smarter defaults, colored output.
`grep` (GNU)	3.11	Content search. Also the OG.
`rg` (ripgrep)	15.1.0	Rust-based `grep` alternative. Respects `.gitignore`, crazy fast.

All benchmarks run with hyperfine --warmup 3 --runs 10 on WSL2 Ubuntu, Intel i7, NVMe SSD.

Benchmark 1: Simple Filename Search (Find All `*.txt` Files)

This is the most common use case. You want every .txt file in a project, recursively.

What I Ran

# GNU find
find . -name '*.txt'

# fd (extension filter)
fd -e txt

# ripgrep listing all files, piped to grep
rg --files | grep '\.txt$'

Results

Benchmark 1: find . -name '*.txt'
  Time (mean ± σ):      94.5 ms ±  17.6 ms    [User: 21.1 ms, System: 26.1 ms]
  Range (min … max):    74.8 ms … 139.9 ms    10 runs

Benchmark 1: fd -e txt
  Time (mean ± σ):      39.9 ms ±   8.2 ms    [User: 70.7 ms, System: 134.3 ms]
  Range (min … max):    30.8 ms …  55.3 ms    10 runs

Benchmark 1: rg --files | grep '\.txt$'
  Time (mean ± σ):     117.6 ms ±  12.8 ms    [User: 51.5 ms, System: 106.0 ms]
  Range (min … max):   104.8 ms … 144.0 ms    10 runs

Tool	Mean Time	vs find
`fd -e txt`	39.9 ms	🏆 2.37x faster
`find . -name '*.txt'`	94.5 ms	baseline
`rg --files \	grep`	117.6 ms

⚠️ The Hidden Files Gotcha

Here's something the benchmarks don't tell you — fd and find returned different results.

$ find . -name '*.txt' | wc -l
3500

$ fd -e txt | wc -l
3000

fd skipped 500 .txt files. Why? Because those 500 files live inside .hidden_dir/, and fd ignores hidden directories by default. It's not a bug — it's intentional. If you want parity with find, you need the -H flag:

$ fd -H -e txt | wc -l
3500

This is either genius or infuriating depending on whether you knew about it before debugging for 20 minutes. (I was debugging for 20 minutes.)

Winner: fd — but learn the -H flag or it'll silently miss files.

Benchmark 2: Content Search (Find Files Containing "test")

You need to know which files reference a string. Classic grep territory.

What I Ran

# GNU grep (excluding .git manually, suppressing permission errors)
grep -r 'test' . --exclude-dir=.git 2>/dev/null

# ripgrep (auto-excludes .git, hidden dirs, binaries)
rg 'test'

Results

Benchmark 1: grep -r 'test' . --exclude-dir=.git 2>/dev/null
  Time (mean ± σ):     302.7 ms ±  50.8 ms    [User: 92.8 ms, System: 100.2 ms]
  Range (min … max):   228.6 ms … 370.8 ms    10 runs

Benchmark 1: rg 'test'
  Time (mean ± σ):     103.2 ms ±   6.8 ms    [User: 135.3 ms, System: 177.5 ms]
  Range (min … max):    95.3 ms … 116.0 ms    10 runs

Tool	Mean Time	vs grep
`rg 'test'`	103.2 ms	🏆 2.93x faster
`grep -r 'test'`	302.7 ms	baseline

And look at that consistency — rg has a standard deviation of 6.8ms vs grep's 50.8ms. rg is not just faster, it's predictably faster.

Both returned exactly 3,500 matches:

$ grep -r 'test' . --exclude-dir=.git 2>/dev/null | wc -l
3500

$ rg 'test' | wc -l
3500

Unlike the filename search test, there's no hidden-file discrepancy here because our "test" string only appears in non-hidden files. But rg is still skipping hidden dirs and .git by default — it just happened to not matter in this case.

Winner: rg — not even close. 3x faster with zero tuning.

Benchmark 3: Finding Hidden Files

Sometimes you need to find all the dotfiles and dotdirs. Let's see who handles this best.

What I Ran

# GNU find — no special flags needed, it sees everything
find . -name '.*' -type f

# fd — needs -H to include hidden stuff, regex anchor for dot-prefix
fd -H -t f '^\.'

# ripgrep — needs --hidden to see dotfiles
rg --hidden --files | grep '^\.'

Results

Benchmark 1: find . -name '.*' -type f
  Time (mean ± σ):     104.3 ms ±  20.5 ms    [User: 16.0 ms, System: 27.6 ms]
  Range (min … max):    79.0 ms … 144.5 ms    10 runs

Benchmark 1: fd -H -t f '^\.'
  Time (mean ± σ):      40.5 ms ±   9.2 ms    [User: 56.9 ms, System: 106.0 ms]
  Range (min … max):    26.6 ms …  57.2 ms    10 runs

Benchmark 1: rg --hidden --files | grep '^\.'
  Time (mean ± σ):     118.8 ms ±   9.4 ms    [User: 64.4 ms, System: 93.3 ms]
  Range (min … max):   106.9 ms … 135.0 ms    10 runs

Tool	Mean Time	vs find
`fd -H -t f '^\.'`	40.5 ms	🏆 2.58x faster
`find . -name '.*' -type f`	104.3 ms	baseline
`rg --hidden --files \	grep`	118.8 ms

All three found exactly 1,500 hidden files (we excluded .git/ objects from this count).

$ find . -name '.*' -type f -not -path './.git/*' | wc -l
1500

$ fd -H -t f '^\.' | wc -l
1500

Winner: fd — once you remember -H.

Benchmark 4: Ignoring `.git` Directories

This is one of fd and rg's marquee features — they auto-ignore .git, .svn, and anything in .gitignore. With find, you have to do it manually.

What I Ran

# GNU find — manual .git exclusion
find . -not -path './.git/*' -type f | wc -l

# fd — auto-ignores .git AND hidden dirs
fd -t f | wc -l

# ripgrep — auto-ignores .git AND hidden dirs
rg --files | wc -l

Results

Benchmark 1: find . -not -path './.git/*' -type f | wc -l
  Time (mean ± σ):     139.2 ms ±  16.5 ms    [User: 27.9 ms, System: 37.6 ms]
  Range (min … max):   119.4 ms … 173.4 ms    10 runs

Benchmark 1: fd -t f | wc -l
  Time (mean ± σ):      85.4 ms ±  10.2 ms    [User: 82.9 ms, System: 118.2 ms]
  Range (min … max):    69.2 ms … 103.9 ms    10 runs

Benchmark 1: rg --files | wc -l
  Time (mean ± σ):     129.0 ms ±  12.2 ms    [User: 60.7 ms, System: 106.3 ms]
  Range (min … max):   111.4 ms … 151.3 ms    10 runs

Tool	Mean Time	vs find
`fd -t f \	wc -l`	85.4 ms
`rg --files \	wc -l`	129.0 ms
`find . -not -path './.git/*' \	wc -l`	139.2 ms

But Again: The Counts Don't Match

$ find . -not -path './.git/*' -type f | wc -l
10400

$ fd -t f | wc -l
8400

That's a 2,000-file discrepancy. Here's the breakdown:

10,900 total files
Minus 500 .git/ objects = 10,400 (what find reports with -not -path)
Minus 2,000 hidden files/dirs = 8,400 (what fd reports by default)

fd and rg don't just skip .git — they skip all hidden files and directories. This is usually what you want (who searches node_modules/.cache/?), but it's worth knowing.

$ fd -H -t f | wc -l    # with hidden files
10900

Winner: fd — but understand what "ignore" actually means.

Bonus Tests

Finding Files by Path Pattern

$ time find . -path '*deep*' -type f | wc -l
1000
real    0m0.088s

$ time fd 'deep' -t f | wc -l
500
real    0m0.094s

Again, fd found half as many because .hidden_dir/subdir/deep_hidden_*.txt (500 files) is in a hidden directory. With -H:

$ fd -H 'deep' -t f | wc -l
1000

Simple File Listing Speed

When neither tool is filtering (just "list everything"), the performance gap narrows:

$ time find . -type f | wc -l
10900
real    0m0.110s

$ time fd -t f | wc -l
8400
real    0m0.116s

At raw directory traversal, they're basically tied. fd's advantage comes from its smarter filtering and parallelism, not from faster syscalls.

The Scorecard

Test	Winner	Margin
Filename search (`*.txt`)	`fd`	2.37x over `find`
Content search (`test`)	`rg`	2.93x over `grep`
Hidden file search	`fd`	2.58x over `find`
.git exclusion + listing	`fd`	1.63x over `find`
Raw listing (no filter)	Tie	~identical

Overall winner: fd + rg as a combo. Replace find with fd, replace grep with rg. You'll never look back.

The Real Talk: When to Use What

Use `fd` when:

You're doing any filename-based search (replace find . -name)
You want smart defaults that skip .git, node_modules, hidden dirs
You want colored, readable output out of the box
You're typing into an interactive shell and want the shorter syntax

Use `find` when:

You're writing a portable script that needs to run on any Linux/Unix
You need the insane flexibility of -exec with complex predicates
You're on a machine where you can't install Rust tooling (embedded, minimal containers)
You need to search hidden files without remembering a flag

Use `rg` when:

You're searching file contents (this is what it was built for)
You want .gitignore-aware searching (no more grepping through node_modules)
You need speed — it's SIMD-accelerated and uses memory mapping

Use `grep` when:

You need POSIX compatibility in scripts
You're piping from stdin with complex flags (grep -oP with Perl regex is still great)
rg isn't installed and you can't install it

The Pipe Combo Pattern (don't do this)

I see this pattern a lot:

rg --files | grep '\.ts$' | xargs rg 'useState'

This is slow and redundant. Both fd and rg can filter by extension natively:

# Instead of the pipe combo:
fd -e ts -x rg 'useState'

# Or even better:
rg --type ts 'useState'

One command. No pipes. Faster.

What I Learned

fd is genuinely faster for filename searches — not by 10x like some blog posts claim, but a solid 2-2.5x in real-world use. That's worth the install.
rg vs grep isn't even a contest — 3x faster with better defaults. If you take one thing from this article: alias grep=rg.
Hidden files will bite you. Both fd and rg skip them by default. This is documented, but the first time you spend 30 minutes wondering why your .env file isn't showing up, you'll remember to add -H / --hidden.
The ergonomics matter more than the speed. Even if fd were the same speed as find, I'd still use it. fd whatever is just nicer than find . -name '*whatever*'. The speed is gravy.
hyperfine is a beautiful benchmarking tool. If you're ever debating tool performance, just run the damn benchmark instead of arguing on Hacker News.

Reproduce This Yourself

# Install the tools
cargo install fd-find ripgrep hyperfine
# or: apt install fd-find ripgrep hyperfine

# Clone my setup (approximate recreation):
mkdir -p /tmp/fd-benchmark && cd /tmp/fd-benchmark
for i in $(seq 1 2000); do echo "test content line $i" > "file_${i}.txt"; done
for i in $(seq 1 1000); do echo "hidden content $i" > ".hidden_${i}"; done
mkdir -p .hidden_dir/subdir
for i in $(seq 1 500); do echo "deep hidden $i" > ".hidden_dir/subdir/deep_hidden_${i}.txt"; done
mkdir -p .git/objects
for i in $(seq 1 500); do echo "git object $i" > ".git/objects/obj_${i}"; done
# ... etc. Full generation script in the article source.

# Run the benchmarks
hyperfine -w 3 -r 10 "find . -name '*.txt'" "fd -e txt"
hyperfine -w 3 -r 10 "grep -r 'test' . --exclude-dir=.git" "rg 'test'"

Last updated: May 2026. Tools tested: find 4.9.0, fd 10.2.0, grep 3.11, rg 15.1.0. Environment: WSL2 Ubuntu on NVMe SSD.

The Hidden Developer Tool Tax: How Much You're Really Spending Every Month

Mike Chen — Fri, 29 May 2026 15:00:33 +0000

The Hidden Developer Tool Tax: How Much You're Really Spending Every Month

I added up my subscriptions last weekend and almost threw up. Not a figure of speech. I literally stared at my screen, did the math three times, and felt a wave of nausea wash over me.

I'm not talking about Netflix or Spotify. I'm talking about the tools I use to do my job. The things I need to write code, push commits, and generally be a functioning developer in 2026.

Here's the thing nobody tells you when you get into software development: there's a subscription tax. It creeps up on you. One day you're using free VS Code and pushing to GitHub, and the next you're somehow paying the equivalent of a car lease to a dozen different SaaS companies.

Let me break this down.

The Actual Cost of Being a Developer in 2026

Here's what these tools actually cost, right now:

Tool	Monthly Cost	What It Does
GitHub Copilot	$10 (individual)	AI code completion in your editor
Cursor Pro	$20	AI-first IDE, 500 fast premium requests
ChatGPT Plus	$20	General AI assistant, GPT-4 access
Claude Pro	$20	Anthropic's assistant, longer conversations
JetBrains All Products	$24.90	Every JetBrains IDE (annual billing)
Windsurf Pro	$15	AI coding IDE by Codeium
Warp Pro	$18	AI-powered terminal
Linear	$8	Issue tracking that doesn't suck
Notion Plus	$10	Docs, wikis, project management
Figma Professional	$15	UI/UX design
1Password	$2.99	Password management
Docker Desktop	$9	Container management (business use)
Postman	$14	API testing and development
ngrok	$8	Local tunnel for webhooks and demos

These aren't made-up numbers. I checked every single pricing page. This is what you pay if you walk up today and subscribe.

Now let's talk about what this looks like in real life, because nobody subscribes to everything. But a lot of us subscribe to way more than we admit.

Tier 1: The "Essential Dev" — $67.89/month ($814.68/year)

This is the baseline. The stuff you actually need to do your job effectively in 2026. I'm talking about a typical employed developer — not some AI-obsessed early adopter, just someone who wants decent tooling.

Here's what that looks like:

GitHub Copilot ($10) — At this point, coding without Copilot feels like typing with one hand. Every employed dev I know pays for this. Some employers cover it. Most don't.
ChatGPT Plus ($20) — For rubber-ducking architecture questions, generating boilerplate, and the 47 daily tasks that are too specific for Stack Overflow.
JetBrains All Products ($24.90) — If you work across multiple languages, the all-products pack is actually a good deal. Annual billing saves you $4/month versus monthly.
1Password ($2.99) — Because reusing passwords in 2026 is how you end up on Have I Been Pwned.
Notion Plus ($10) — Documentation, sprint notes, personal knowledge base. The free tier runs out of storage surprisingly fast.

Total: $67.89/month. That's $814.68 per year.

For context, that's more than a Disney+ annual subscription, a decent phone plan, or roughly 16 burritos from Chipotle. And this is the conservative estimate.

Tier 2: The "AI Power User" — $148.89/month ($1,786.68/year)

This is where things get embarrassing. If you're the kind of developer who has opinions about which LLM is best for which task, this is you. I say this with love. I am this person.

Everything in Tier 1: $67.89
Cursor Pro ($20) — Because sometimes Copilot isn't enough and you want an IDE that's built around AI from the ground up.
Claude Pro ($20) — Anthropic's models are genuinely better at certain things — long-form code refactoring, architecture discussions, anything requiring deep reasoning. So you pay for both ChatGPT and Claude.
Windsurf Pro ($15) — Maybe you're evaluating it against Cursor. Maybe you like the cascade mode. Either way, another $15 gone.
Warp Pro ($18) — AI in your terminal. Sounds ridiculous until you use it for a week and can't go back. The natural-language-to-command feature alone saves me from Googling "tar extract specific directory" for the 400th time.
Linear ($8) — Because Jira makes you want to quit your job, and Linear is what project management looks like when the people building it actually use it.

Total: $148.89/month. That's $1,786.68 per year.

I want you to sit with that number for a second. Nearly two thousand dollars a year. On developer tools. Tools that didn't exist five years ago. Tools that, if we're being honest, some of us are still figuring out how to use effectively.

And we haven't even hit the full-stack indie tier yet.

Tier 3: The "Full Stack Indie" — $194.89/month ($2,338.68/year)

This is the solo developer or indie hacker who touches every part of the stack. Frontend, backend, design, infrastructure — you're doing it all, and you're paying for tools across every domain.

Everything in Tier 2: $148.89
Figma Professional ($15) — You're designing your own UI, and Figma's free tier limits you to a handful of files. Professional gives you unlimited drafts and team libraries.
Docker Desktop ($9) — The free version is fine for personal use, but if you're running a business (even a solo LLC), you technically need the paid tier. $9/month to avoid the license police.
Postman ($14) — Free Postman is surprisingly capable, but the moment you need collections with more than a few endpoints or want to share with a team, you're paying.
ngrok ($8) — Webhook testing, local demos for clients, exposing a dev server for a quick review. The free tier gives you one tunnel with a random URL that changes every time. The $8 plan gives you reserved domains and slightly longer sessions.

Total: $194.89/month. That's $2,338.68 per year.

Two thousand three hundred dollars. Every year. On subscriptions.

I could buy a MacBook Air every three years with that money. I could fly to Europe. I could invest it and have something like $70,000 by the time I retire, assuming average market returns.

Instead, I'm paying for seven different ways to generate code with AI.

The Free Alternatives That Actually Work

Before you cancel everything and quit tech to become a farmer, let me tell you what I found when I actually tried to cut costs.

VS Code + free Copilot tier — GitHub Copilot now offers 2,000 completions per month for free. If you're not a heavy user, this is genuinely enough. Combined with VS Code (which is free and excellent), you can skip both Copilot paid and JetBrains.

Bitwarden instead of 1Password — Free, open-source, and does everything 1Password does. The UI isn't quite as polished, but your passwords don't care about polish.

ChatGPT/Claude free tiers — Both have free tiers that are genuinely useful. You'll hit rate limits, but if you batch your questions instead of chatting with AI all day, it works.

Colima or Rancher Desktop instead of Docker Desktop — Both are free, open-source, and do the same thing. Podman is also free and ships with most Linux distros.

Linear free tier — Surprisingly generous for solo developers. Unlimited issues, basic workflows. You only pay when you need teams or advanced views.

Figma free tier — You get three Figma and three FigJam files. If you're disciplined about archiving old work, this is enough for side projects.

Bruno or Hoppscotch instead of Postman — Bruno stores collections as plain text files in your repo, which means no vendor lock-in. Hoppscotch is a lightweight web-based alternative.

Notion free tier — Generous for personal use. You only hit limits when collaborating with large teams or uploading tons of files.

If I went full cheapskate, here's what I'd actually pay:

GitHub Copilot free tier: $0
VS Code: $0
ChatGPT free: $0
Bitwarden: $0
Linear free: $0
Figma free: $0
Bruno instead of Postman: $0
ngrok free: $0
Colima instead of Docker Desktop: $0

Total: $0/month.

Zero dollars. The same tools I was paying nearly $200/month for, with slightly more generous limits and shinier UIs, are available for free. The functionality is 85% the same. The remaining 15% is mostly convenience, and I'm not sure convenience is worth two grand a year.

How to Audit Your Own Subscriptions

Here's what I did. It took 15 minutes.

Open your bank app. Search for "subscription," "monthly," or the name of every tool I listed above. You'll find things you forgot about. I found a Postman Pro subscription I hadn't used in four months.
Write them all down. Every single one. The total will probably be higher than you think. That's the point.
For each one, ask yourself: Did I use this in the last 30 days? If the answer is no, cancel it immediately. You can always resubscribe later — they make it very easy to give them money again.
For the ones you do use: Is there a free alternative that does 80% of what you need? Try it for a week. Most of the time, 80% is actually enough.
Annual vs. monthly: If you're keeping a subscription, switch to annual billing. Almost every tool gives you ~15-20% off. But only do this for things you're certain you'll use all year.

The Bottom Line

I'm not saying you should cancel everything and code in Notepad. Good tools are worth paying for. The developers who build these tools deserve to eat.

But there's a difference between paying for tools that genuinely make you better at your job, and passively bleeding money to a dozen subscriptions you barely use.

I did the audit. I canceled five subscriptions. I'm saving $86/month — over a thousand dollars a year. And the funny thing is, I don't miss any of them.

The tool tax is real. But it's also optional. You just have to actually look at what you're paying, which — let's be honest — most of us have been avoiding.

Go check your subscriptions. I'll wait.

I Tested 5 AI Coding Tools for 30 Days — Here's What Actually Works

Mike Chen — Wed, 27 May 2026 18:06:54 +0000

Honest, hands-on comparison. No hype. Real test results where possible.

I spent a month putting five AI coding tools through their paces — from terminal-native CLI tools to full-blown AI IDEs. Some I tested directly. Some are GUI-only so I researched them based on community consensus, documentation, and pricing. Here's what I learned.

The Contenders

#	Tool	Type	Starting Price
1	GitHub Copilot	IDE Extension + CLI	Free / $10/mo
2	Claude Code	Terminal CLI	Pay-per-use (Anthropic API)
3	Cursor	GUI IDE (VS Code fork)	Free / $20/mo
4	Windsurf	GUI IDE	Free / $15/mo
5	Aider	Terminal CLI (open-source)	Free + your own API key

How I Tested

For each tool where testing was possible, I ran real commands on a Linux (WSL) environment with Node.js v24 and Python 3 available. For GUI-only tools (Cursor, Windsurf), I compiled information from official docs, pricing pages, and community reports. Where a tool couldn't be tested (missing credentials, wrong package), I'm upfront about it.

1. GitHub Copilot

What It Is

The original AI coding assistant. GitHub Copilot started as inline code completions and has grown into a full suite: Chat, multi-file Edits, agent mode (Coding Agent), code review, and CLI access via gh copilot.

Pricing

Free: 2,000 completions/month + 50 chat messages
Individual: $10/month or $100/year (unlimited completions, unlimited chat)
Business: $19/user/month (adds org policies, IP indemnity)
Enterprise: $39/user/month (adds custom models, knowledge bases)

Models Available

GPT-4o, Claude 3.5 Sonnet, Gemini 2.0 Flash, o1, o3-mini — you can switch between them.

My Test Result: ❌ Could Not Test

gh CLI was not installed in my environment, so I couldn't run gh copilot suggest or gh copilot explain. Based on extensive community feedback, Copilot's inline completions remain the gold standard for speed, but its multi-file agent mode is still maturing compared to Cursor and Claude Code.

Pros

Deepest IDE integration (VS Code, JetBrains, Neovim, Xcode)
Fast, low-latency completions
Multiple model choice
Free tier is genuinely usable

Cons

Agent mode lags behind Cursor's Composer
Chat context window is smaller than Claude Code
$10/month adds up if you also pay for other tools

2. Claude Code (CLI)

What It Is

Anthropic's terminal-native AI coding agent. It runs in your terminal, reads your entire codebase, and can make multi-file edits, run tests, fix bugs, and handle git workflows — all from the command line. Think of it as an autonomous AI developer you talk to.

Pricing

Pay-per-use via the Anthropic API. Claude 3.5 Sonnet costs ~$3/$15 per million input/output tokens. Max $200/month cap on the Max plan. Realistic monthly cost for active daily use: $10–$50 depending on project size.

Installation

npx @anthropic-ai/claude-code
# Or install globally:
npm install -g @anthropic-ai/claude-code

My Test Result: ✅ Installed, ⚠️ Requires Auth

$ npx --yes @anthropic-ai/claude-code --version
# Output: 2.1.152 (Claude Code)

Claude Code installed cleanly in under 10 seconds via npx. However, running it requires an Anthropic API key and /login. Without credentials, I couldn't test code generation — but the CLI itself was snappy and well-built. Community consensus: Claude Code is currently the best CLI agent for complex, multi-file tasks when budget isn't a concern.

Pros

Most capable CLI agent on the market
Reads your entire codebase (not just open files)
Autonomous bug-fixing and refactoring
Git-aware — makes commits, manages branches
No GUI overhead — works over SSH, in tmux, anywhere

Cons

Pay-per-use pricing can surprise you on big projects
Requires Anthropic account + API key
Slower than inline completions (it thinks before acting)
Not an IDE — no autocomplete while you type

3. Cursor

⚠️ Not directly tested — GUI-only IDE, researched from official docs and community reports.

What It Is

Cursor is a VS Code fork rebuilt from the ground up around AI. It doesn't just bolt AI onto an editor — the editor itself is designed for AI interaction. The key feature is Composer, which can plan and execute multi-file changes autonomously, and Agent mode, which can run terminal commands, install packages, and iterate on errors.

Pricing

Hobby (Free): 2,000 completions, 50 slow premium requests/month
Pro ($20/month): Unlimited completions, 500 fast premium requests/month (+ $0.04/extra)
Business ($40/user/month): Adds centralized billing, admin controls, privacy mode

Key Features

Tab: AI-powered next-edit prediction (better than Copilot's, many say)
Cmd+K: Inline editing — select code, describe the change, Cursor rewrites it
Chat with @codebase: Ask questions about your entire project
Composer: Multi-file agent that plans then executes
Agent mode: Composer on steroids — runs commands, fixes its own errors
.cursorrules: Project-wide AI behavior rules
Model choice: Claude 3.5/3.7 Sonnet, GPT-4o, GPT-4.1, and custom models

Pros

Best multi-file editing experience (Composer is genuinely impressive)
Tab predictions feel more contextual than Copilot
Agent mode can handle end-to-end tasks (build a feature, fix a bug)
Privacy mode available (zero data retention on Business plan)
Active development — features ship weekly

Cons

$20/month is steep alongside other subscriptions
500 fast requests run out quickly for power users (extra requests cost more)
VS Code extension ecosystem works but occasional compatibility issues
Privacy concerns — code passes through Cursor's servers (unless on Business plan)

4. Windsurf

⚠️ Not directly tested — GUI-only IDE, researched from official docs and community reports.

What It Is

Windsurf is Codeium's AI-native IDE. Its standout feature is Cascade, a new interaction paradigm that blends autocomplete, chat, and agent behavior into a single "flow" — the AI continuously understands what you're doing and offers help proactively. It also has Supercomplete, which predicts not just the next line but multi-line edits at your cursor.

Pricing

Free: Basic autocomplete + chat, 50 premium credits/month
Pro ($15/month): Unlimited premium models, 1,500 credits/month ($0.01/extra)
Teams ($35/user/month): Admin tools, centralized billing

Key Features

Cascade: Hybrid copilot + agent in one continuous flow
Supercomplete: Multi-line edit predictions (not just text insertion)
Inline Command (Cmd+I): Natural language edits at cursor position
Memories: Learns your coding style and conventions over time
Natural-language terminal: Describe what you want in plain English
Multi-model: Claude 3.5 Sonnet, GPT-4o, DeepSeek, Gemini, proprietary models

Pros

Cascade's "flow" feels more natural than switching between chat/composer
Supercomplete is unique — predicts edits, not just completions
Slightly cheaper than Cursor at $15/month
Proprietary models handle basic tasks free (no API costs for them)
Memories feature gets better the more you use it

Cons

Smaller community than Cursor — fewer tutorials, plugins, tips
Cascade can be overly aggressive in offering changes
1,500 credits/month can disappear fast on complex tasks
Still maturing — occasional instability on edge cases

5. Aider

What It Is

Aider is the open-source CLI champion. It's a terminal-based AI pair programmer that works with almost any LLM — Claude, GPT-4, local models via Ollama — and automatically commits changes to git. It builds a "repository map" so the AI understands your full codebase structure, not just the files you're editing.

Pricing

Free (MIT license). You pay only for the API calls to your chosen LLM provider. With Claude 3.5 Sonnet at ~$3/$15 per million input/output tokens, active users typically spend $5–$20/month on API costs.

Installation

pip install aider-chat
# Set your API key
export ANTHROPIC_API_KEY=sk-ant-...  # or OPENAI_API_KEY
# Start coding
aider

My Test Result: ⚠️ Partial

$ pip3 install aider-chat
# WARNING: Package(s) not found: aider-chat

The pip package failed due to PEP 668 environment restrictions in my WSL setup. Note: installing aider (without -chat) pulls an unrelated library — the correct package is aider-chat. Aider remains one of the most starred AI coding tools on GitHub (29k+ stars), and users consistently report it produces the highest-quality multi-file edits of any CLI tool.

Pros

Truly free — no subscription, just API costs
Works with any LLM — plug in Claude, GPT-4, Gemini, or local models
Open-source — you can read the code, audit it, fork it
Git integration — every edit is a clean commit, easy to revert
Best-in-class codebase awareness via repository map
/voice mode for hands-free coding
Active community, fast iteration (architect/editor mode in v0.82+)

Cons

CLI-only — no mouse, no inline suggestions while you type
Setup requires API keys and Python environment knowledge
Not for non-technical users
Repository map generation can be slow on large codebases
No official IDE integration (community plugins exist but aren't polished)

Side-by-Side Comparison

Feature	GitHub Copilot	Claude Code	Cursor	Windsurf	Aider
Type	IDE Extension	Terminal CLI	GUI IDE	GUI IDE	Terminal CLI
Free tier	✅ Yes	❌ No	✅ Limited	✅ Limited	✅ (API only)
Paid starts at	$10/mo	Pay-per-use	$20/mo	$15/mo	~$5–20/mo API
Inline completions	⭐⭐⭐⭐⭐	❌ N/A	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	❌ N/A
Multi-file agent	⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐⭐
IDE integration	VS Code, JB, NeoVim	Terminal only	VS Code fork	Standalone	Terminal only
Open-source	❌	❌	❌	❌	✅
Local models	❌	❌	Limited	❌	✅ (Ollama)
Git integration	Basic	✅	✅	✅	⭐⭐⭐⭐⭐
Best for	Daily typing	Complex tasks	Full workflow	Flow-based dev	Budget + control

The Verdict: Which One Should You Use?

Use GitHub Copilot if...

You want the best inline completions that just work. Copilot's tab-complete is still the fastest way to write boilerplate, fill in patterns, and reduce keyboard mileage. The free tier is genuinely useful, and at $10/month it's the safest bet for most developers. Pair it with something else for complex agent tasks.

Use Claude Code if...

You work in the terminal, need an autonomous agent that understands your entire codebase, and don't mind pay-per-use pricing. It's the most capable CLI agent available — especially for large refactors, debugging sessions, and complex feature builds. A budget cap ($200/month Max plan) prevents surprises.

Use Cursor if...

You want the best all-in-one AI coding experience. Cursor's Composer + Agent mode is the closest thing to "describe a feature and watch it get built." The Tab predictions are arguably better than Copilot's. At $20/month it's the premium option, but it replaces both Copilot and Claude Code for most workflows.

Use Windsurf if...

You like the idea of Cursor but want a more "flowy" experience and slightly lower price. Cascade's continuous-awareness paradigm feels different — more proactive, less back-and-forth. The Memories feature genuinely improves over time. At $15/month it undercuts Cursor.

Use Aider if...

You want maximum control, zero subscriptions, and don't mind the terminal. Aider with Claude 3.5 Sonnet produces some of the highest-quality code edits I've seen. It's open-source, works with local models via Ollama (privacy bonus), and its git workflow is the cleanest of any tool here. If you're comfortable in the terminal, this is the budget-power-user sweet spot.

My Personal Stack

After 30 days, here's what I landed on:

Cursor for daily coding — Composer handles complex tasks, Tab handles the mundane
Claude Code via npx for one-off terminal tasks, large refactors, and when I'm working over SSH
Aider + Ollama for privacy-sensitive projects where code must stay local

Total monthly cost: $20 (Cursor Pro) + ~$10 (Anthropic API) = ~$30/month. Your mileage will vary.

Honest Reality Check

None of these tools are magic. They all:

Produce bugs with confidence
Hallucinate APIs that don't exist
Need human review for every non-trivial change

But when used correctly — as accelerators, not replacements — they genuinely 2–3x coding speed on many tasks. The real skill is learning when to trust the AI and when to take over yourself. That's the part no tool can do for you.

Last updated: May 2026. Pricing current as of publication date. Tested on WSL/Linux with Node.js v24.16.0 and Python 3.14.

DEV Community: Mike Chen

How I Built a Zero-Server Image Editor for 0¥/Month

How I Built a Zero-Server Image Editor for 0¥/Month

The Stack: Zero Dependencies on the Server

What It Does

The Layer System

GIF Encoding in the Browser

Why "100% Local" Matters

Cost: ~16¥/Month

The Traffic Problem

fd vs find vs ripgrep: I Created 10,000 Files to Settle This Debate

fd vs find vs ripgrep: I Created 10,000 Files to Settle This Debate

Why I Did This

Methodology

The Test Bed

Tools Tested

Benchmark 1: Simple Filename Search (Find All *.txt Files)

What I Ran

Results

⚠️ The Hidden Files Gotcha

Benchmark 2: Content Search (Find Files Containing "test")

What I Ran

Results

Benchmark 3: Finding Hidden Files

What I Ran

Results

Benchmark 4: Ignoring .git Directories

What I Ran

Results

But Again: The Counts Don't Match

Bonus Tests

Finding Files by Path Pattern

Simple File Listing Speed

The Scorecard

The Real Talk: When to Use What

Use fd when:

Use find when:

Use rg when:

Use grep when:

The Pipe Combo Pattern (don't do this)

What I Learned

Reproduce This Yourself

The Hidden Developer Tool Tax: How Much You're Really Spending Every Month

The Hidden Developer Tool Tax: How Much You're Really Spending Every Month

The Actual Cost of Being a Developer in 2026

Tier 1: The "Essential Dev" — $67.89/month ($814.68/year)

Tier 2: The "AI Power User" — $148.89/month ($1,786.68/year)

Tier 3: The "Full Stack Indie" — $194.89/month ($2,338.68/year)

The Free Alternatives That Actually Work

How to Audit Your Own Subscriptions

The Bottom Line

I Tested 5 AI Coding Tools for 30 Days — Here's What Actually Works

The Contenders

How I Tested

1. GitHub Copilot

What It Is

Pricing

Models Available

My Test Result: ❌ Could Not Test

Pros

Cons

2. Claude Code (CLI)

What It Is

Pricing

Installation

My Test Result: ✅ Installed, ⚠️ Requires Auth

Pros

Cons

3. Cursor

What It Is

Pricing

Key Features

Pros

Cons

4. Windsurf

What It Is

Pricing

Key Features

Pros

Cons

Benchmark 1: Simple Filename Search (Find All `*.txt` Files)

Benchmark 4: Ignoring `.git` Directories

Use `fd` when:

Use `find` when:

Use `rg` when:

Use `grep` when: