Building AI-Tools: Why I Spent 3 Months Cataloging 125+ AI Tools and What I Actually Learned

Honestly, I didn't expect this project to become what it is today.

It started innocently enough back in March. I was tired of seeing the same "Top 10 AI Tools" lists everywhere—you know the ones, every list includes ChatGPT, MidJourney, Notion AI, and five tools you've never heard of that all do basically the same thing. Every article is sponsored, every recommendation feels fake, and nothing tells you what actually works for real developers.

So I thought, "Why not just catalog every AI tool I try, honestly, with pros and cons? Keep it open source, keep it updated, let the community contribute."

Three months and 125 tools later... well, I learned way more than I bargained for. Let me walk you through what I built, what surprised me, and why maybe you shouldn't do what I did (but also why you should).

---

What Is AI-Tools Anyway?

AI-Tools is an open source curated list of AI tools—125+ and counting—with honest reviews, pros, cons, and actual usage notes. The idea is simple:

Every tool gets a real human review, not marketing copy. Tell me what it's good for, what it's bad for, and who should actually use it.

You can browse it on GitHub here: https://github.com/kevinten10/AI-Tools

Here's the structure I ended up with:

## Category: Code Assistants
- [GitHub Copilot](https://github.com/copilot)
  - **Price**: $10/month
  - **Best for**: Daily autocomplete, boilerplate generation
  - **Pros**: Works everywhere, good enough most of the time, integrates with all your editors
  - **Cons**: Hallucinates library methods, can't understand your entire codebase well
  - **My rating**: 4/5 - Use it every day, wouldn't pay $20/month though
  - **Who should use**: Every developer, it's worth the $10
...

Pretty straightforward, right? Just a simple markdown file with everything organized. No fancy website, no AI-generated summaries, just human words.

Wait—why no website? Honestly, maintaining a list is enough. If someone wants to build a fancy frontend on top of it, they can. I just wanted the content to be open and version-controlled.

---

The Stack: Keep It Simple Stupid

So here's the thing—I didn't overengineer this. That's actually the one thing I'm proud of.

The entire project is:

1. One markdown file with the list
2. Simple README explaining how to contribute
3. Apache 2.0 license—do whatever you want with it

That's it. No React app, no database, no CMS. Just markdown.

But wait, did I learn anything technical along the way? Of course I did. Let me share the code I use to keep everything organized—a simple Node.js script that validates the formatting and checks for dead links.

Here's the validation script I use, you can steal it:

const fs = require('fs');
const path = require('path');
const https = require('https');

function parseList(content) {
  const lines = content.split('\n');
  const errors = [];
  let currentCategory = null;
  let currentTool = null;

  lines.forEach((line, index) => {
    const lineNum = index + 1;

    // Check category format
    if (line.startsWith('## ')) {
      currentCategory = line.replace('## ', '').trim();
      if (!currentCategory.includes(':')) {
        errors.push(`Line ${lineNum}: Category missing colon: ${currentCategory}`);
      }
      currentTool = null;
      return;
    }

    // Check tool format
    if (line.startsWith('- [')) {
      currentTool = { name: '', lineNum };
      if (!line.includes('](') || !line.endsWith(')')) {
        errors.push(`Line ${lineNum}: Tool link format incorrect: ${line}`);
      }
      return;
    }

    // Check bullet points under tool
    if (currentTool && line.startsWith('  - **')) {
      if (!line.includes('**: ')) {
        errors.push(`Line ${lineNum}: Property format incorrect (needs **Name**: ): ${line}`);
      }
    }
  });

  return errors;
}

// Read the file
const content = fs.readFileSync(path.join(__dirname, '../README.md'), 'utf8');
const errors = parseList(content);

if (errors.length > 0) {
  console.log('❌ Found formatting errors:');
  errors.forEach(e => console.log('  -', e));
  process.exit(1);
} else {
  console.log('✅ All formatting checks passed!');
  process.exit(0);
}

Pretty simple, right? It runs on every PR via GitHub Actions. This catches most of the contribution mistakes automatically so I don't have to.

The GitHub Action config looks like this:

name: Validate List Format
on: [pull_request, push]

jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 22
      - run: node scripts/validate.js

That's the entire CI/CD pipeline. Less than 50 lines of code total. No fancy stuff needed.

Pros of this approach:

• ✅ Zero hosting costs
• ✅ Always available as long as GitHub exists
• ✅ Easy to contribute—just edit the markdown
• ✅ Version control for every change
• ✅ Anyone can fork it and build their own version

Cons of this approach:

• ❌ No search (unless you use browser find)
• ❌ No filtering by price/rating/category
• ❌ Less accessible to non-GitHub users

Would I do it differently now? Maybe add a simple static site with search someday. But honestly, I like the simplicity. It's lasted three months this way, and I haven't gotten bored maintaining it yet.

---

The Real Lessons: What I Didn't Expect

Okay, let's get to the good stuff—what I actually learned after cataloging 125+ AI tools. Some of this surprised me.

1. Most AI Tools Are Solving Problems You Don't Have

Honestly. Like, how many "AI podcast summarizers" do we really need? I counted 17 different tools that basically do the same thing: take an audio file, transcribe it, summarize it.

Seventeen.

Don't get me wrong—it's a good problem to solve. But do we need seventeen startups all going after the same exact niche? That's what the AI boom looks like right now—everyone is chasing the same low-hanging fruit.

The VCs are funding anything with "AI" in the name, so you get a dozen tools doing the same thing. Most of them won't exist in a year.

2. The Best AI Tools Are Still The Big Ones

After trying 125+ tools, I still use:

• GitHub Copilot for coding
• ChatGPT for debugging and explaining things
• Claude for longer context documents
• MidJourney when I need images for blog posts

That's it. 90% of my AI usage is still those four tools. All the other tools I tried—most of them I don't go back to.

Does that mean the other tools are bad? No, not necessarily. But they're solving problems that aren't problems for me. Maybe they're problems for someone else.

3. Price Tells You Almost Nothing

Some of the best tools I found are completely free. Some of the most expensive tools I tried are absolutely terrible.

For example:

• Free, amazing: Chatbot UI — self-host your own ChatGPT interface, works with any API key, better than the official OpenAI interface in my opinion.
• Expensive, disappointing: That $50/month "AI写作助手" that just rewrites sentences to be more "professional"—who needs that? Not me, not any writer I know.

So here's the thing: don't pay for an AI tool until you've tried the free tier for two weeks and actually use it at least three times. Most subscriptions you'll cancel anyway.

4. The "Best" AI Tool Depends Entirely On Your Use Case

People keep asking me "what's the best AI code assistant?" and I can't give them a straight answer. Because it depends:

• If you want it integrated everywhere and don't mind paying $10/month: GitHub Copilot
• If you want open source and self-host: CodeLlama + Ollama
• If you need better reasoning: Claude 3.5 Sonnet through Continue.dev
• If you can't pay anything: GPT-4o-mini is free enough for most things

There is no single "best"—it's all about what you need, what your constraints are, and what you're comfortable with.

I learned the hard way that recommending "the best" tool is just setting people up for disappointment. Your mileage will vary.

5. People Actually Want Honesty Over Hype

This was the biggest surprise. When I started this, I thought people just wanted another big list. But what people actually thank me for is the honesty.

Like, I'll say things like:

This tool is really popular, but I found it too slow for daily use and the free tier has way too many limits. Probably great if you need the specific feature, but not worth it for me.

Or:

Honestly, I don't understand why this is so popular. It does something you can already do with a simple prompt to ChatGPT and charges you $20/month for it. Save your money.

People tell me that's what they've been wanting. All the other tech blogs are too busy getting sponsored to tell you when something sucks. I don't have sponsors, so I can tell the truth.

That's been the most valuable part of the whole project, honestly.

---

Pros and Cons of This Whole Project

Let me be honest with you—should you start a project like this? Let's break it down.

What Went Well (Pros)

1. I discovered actually useful tools I wouldn't have found otherwise

   • Found some amazing niche tools that solve specific problems I had. Like Mermaid Chart for editing diagrams—game changer for documentation.

2. The community actually contributes

   • I've gotten 15+ PRs from people adding tools I missed, fixing broken links, updating ratings. That's been awesome. Open source works when people actually care.

3. It's become a useful resource that people actually use

   • I've had dozens of people tell me they bookmark it and go back when they're looking for a new AI tool. That feels good—actually building something useful.

4. Zero cost to maintain

   • GitHub hosts it for free, CI runs for free, domain isn't even needed. The whole project costs me $0. Hard to beat that.

What Didn't Go Well (Cons)

1. It takes way more time than you think

   • I thought I'd spend a few weekends on it. Nope—three months later, I'm still updating it when I try new tools. It's not a lot of work, but it's ongoing.

2. Discoverability is terrible on GitHub

   • Unless people know it exists, they won't find it. GitHub isn't great for discoverability. I should probably write some blog posts about it (like this one!), but that's more work.

3. Category overlap is a real problem

   • Some tools fit into multiple categories. Should I put ChatGPT in "Chatbots" and "Writing Assistants" and "Code Assistants"? I still don't have a good answer. Currently I just put it in one place and link it, but that's not perfect.

4. The "validation paradox"—I can't actually test every tool deeply

   • With 125+ tools, I can't spend a week with each one. Some reviews are based on a few hours of testing. That means I might miss things. I'm honest about that in the README, but it's still a limitation.

---

Who Is This Project For?

Okay, so who should actually go check out AI-Tools?

You should check it out if:

• You're feeling overwhelmed by all the new AI tools popping up every week
• You want honest opinions from someone who isn't getting paid to promote anything
• You're looking for a tool to solve a specific problem and want to see all your options in one place
• You want to contribute your own experiences with AI tools

You shouldn't bother if:

• You're happy with the AI tools you already use
• You don't trust any human curation and want an AI to recommend everything to you
• You hate GitHub and just want a pretty website (maybe someday, I promise)

---

Contributing: It's Easier Than You Think

Want to add a tool I missed? Or update my review because you had a different experience?

Contributing is super simple:

1. Fork the repository
2. Edit the README.md file
3. Add your tool following the existing format
4. Open a pull request

The CI will automatically check your formatting, and I'll merge it usually within 24 hours if it looks good.

I don't have strict contribution guidelines—if your review is honest and follows the format, it's going in. Whether you love the tool or hate it, I want your perspective.

---

So Here's The Thing...

Starting this project three months ago, I thought I'd be creating a useful resource for other people. Which I did, that part is true.

But honestly, I've gotten more out of it than anyone else. I've tried so many different approaches to AI tool building, seen what works and what doesn't, and I understand the ecosystem way better than I did before.

Would I do it again? Yeah, probably. Even though it's taken more time than I expected, it's been worth it. The community has been great, and I use my own list all the time when I'm looking for something new.

But if you're thinking about starting something similar—be prepared for it to take on a life of its own. What starts as a simple weekend project can become an ongoing thing. Not that that's bad. It's just... different than what you expect.

---

Your Turn

What's the most surprising AI tool you've tried recently? Good surprising or bad surprising? Did you find a hidden gem that nobody else is talking about? Or did you waste money on a hyped tool that turned out to be garbage?

Drop a comment below and let me know—and if you want to add it to the list, just open a PR on GitHub!

I'm always looking for new tools to add, and I especially want your honest perspective. The whole point of this project is that it's not just my opinion—it's the community's.

---

P.S. If you found this helpful, feel free to star the repo on GitHub—it helps other people find it. Every star helps, and I appreciate it! ⭐