DEV Community: Job

Companies Like DataAnnotation.Tech & Mercor

Job — Sat, 20 Sep 2025 13:46:21 +0000

I've been watching the explosion of companies hiring AI trainers. What started with Data Annotation Tech has turned into an entire ecosystem. Students, freelancers, and remote workers are all chasing these gigs that pay $15-30 an hour for training AI models.

The market is flooded now. Here's the complete list of what I'm seeing.

Complete List of AI Training Companies

Rise Data Labs: New player, catching up
Scale AI: Over 100 trainer positions, infrastructure leader
Outlier: Up to $30/hour for coding, quick onboarding, weekly pay
Stellar AI: $25 minimum rate, PayPal payments
Data Annotation Tech: The original, consistent work flow
Mercor: Recruiting for OpenAI Expert Model Trainers
Invisible Technologies: Domain experts (workplace issues reported)
Alignerr: Similar work to DA, decent pay
SuperAnnotate: Data labeling and AI training
Micro1: Emerging in the space
Handshake: Expanding AI training division
Appen: Global platform, various AI projects
Remotasks (Scale AI subsidiary): Overflow work
TELUS International: AI Rater positions
OneForma: WFH AI training roles
Clickworker: Microtasks and AI training
TaskUs: Customer service + AI training
Labelbox: Data labeling focus
Amazon Mechanical Turk: Crowdsourced AI tasks
WeLocalize: Localization + AI training
Babel.Audio: Voice recording for AI (sells voice rights)
Prolific: Research studies, some AI work
Cloud Connect: Adding more AI studies

What These AI Training Companies Actually Do

They're all middlemen. AI labs need training data and human feedback but don't want to hire thousands of contractors directly. These companies handle the logistics, screening, and payments.

You evaluate model outputs, write training examples, rank responses, or fix code. The work is repetitive but requires domain knowledge. If you can code, you get the higher-paying projects.

What It’s Really Like

Most of these companies have the same problems. Work comes in waves, then disappears for weeks. Pay is decent but inconsistent. Getting accepted is getting harder as they have enough people.

Outlier rejects people with math degrees for failing their math tests. Stellar AI isn't really hiring despite keeping applications open. Invisible laid off entire teams when their project manager got arrested.

Which Ones Are Worth It

From what I'm seeing in forums:

Best for beginners: Outlier, Mercor
Best pay: Stellar AI (if you can get in), coding work on Outlier
Most consistent work: Rise Data Labs, Scale AI, Data Annotation Tech

Red flags: Companies asking to send you equipment or checks upfront. Anything that sounds too good to be true probably is.

Proceed with caution

This entire ecosystem exists because AI training needs human judgment at scale. But the endgame is reducing that human dependency. These companies are building themselves out of their current business model.

The smart ones know this. They're positioning themselves as AI training infrastructure rather than just human labor platforms. The ones that don't adapt will disappear when the demand for manual training drops.

If you're doing this work, treat it as temporary income while building other skills. The AI training gold rush is real money right now, but it won't last forever.

Thoughts from fellow vibe coders?

Job — Sat, 13 Sep 2025 18:38:02 +0000

Hiring SWEs AI Trainers Won't Last

Job ・ Sep 13

#openai #rlhf

Hiring SWEs AI Trainers Won't Last

Job — Sat, 13 Sep 2025 18:09:52 +0000

Companies are desperately hiring "SWE AI Trainers." Mercor is recruiting for most frontier AI Labs. Invisible wants experts for AI training roles. Scale AI has over 100 trainer positions open. New players like Rise Data Labs, Micro1, and Handshake are catching up.

And I think this won't last.

AI labs need domain experts who can spot what generalist trainers miss. When Claude suggests code that compiles but has a memory leak, you want someone who's debugged production crashes reviewing that output.

These trainers write examples, evaluate outputs, fine-tune reward models. It's RLHF but with actual engineering expertise.

That’s the short-term fix.

Because every time I use Cursor or Claude to code, I’m already:

Evaluating the AI's suggestion (accept/modify/reject)
Generating training data through my interactions
Working naturally, not performing artificial tasks

I'm essentially a distributed evaluator every time I code with AI. So is every other developer using these tools.

Users Are Already Trainers

Traditional AI training pays specialists to create evals and examples. But coding AI gets this for free. When I reject a suggestion, modify it, or build on it, that's a training signal.

My debugging sessions, refactoring choices, and architectural decisions are exactly what AI labs pay SWE trainers to demonstrate manually.

Data > Compute

The industry shifted from compute-limited to data-limited. Coding assistants sitting on millions of real developer interactions have something AI labs can't easily replicate.

I think coding assistants and agents will stop relying on foundation models and train their own specialized ones. Cursor with their IDE, and Replit with their development environment all sit on massive datasets of real developer interactions.

Why pay for general capabilities when you have domain-specific interaction data?

The feedback loop compounds: better models get more users, more users generate better training data, better training data creates better models.

As AI labs launch their own code agents, Cursor's next move should be building their own subject-specific LLMs.

They have the data. Why keep paying for foundation models when you can train specialized ones that understand your users' exact workflows?

SWE AI Trainers future

The current SWE trainer hiring is bootstrapping. Once these tools have enough user data, the manual training becomes redundant. The specialized knowledge gets captured through millions of real developer interactions.

Coding assistants will train their own models on user interaction data. This becomes their primary advantage against AI labs entering the space. It's also more efficient than paying for general compute and fine-tuning.

This pattern will repeat in other expert-heavy domains where AI integrates into workflows. Anywhere natural human-in-the-loop feedback exists, specialized trainers are temporary.

The current hiring trendfor SWE AI trainers is real money, but it's a bridge to something else.

AI Color Palette Generator

Job — Tue, 26 Nov 2024 01:09:15 +0000

After weeks fine-tuning, my AI color palette generator is finally live. For those who've seen my previous posts about this project - yes, it's that one!

What it does:

Feed it any description, and it spits out a color palette. Simple as that. Want colors for a "retro terminal interface" or "cyberpunk dashboard"? The AI's got you covered.

Some nerdy prompts to try:

"Matrix-inspired terminal"
"Synthwave code editor"
"Minimal dark mode UI"
"Futuristic OS interface"
"8-bit gaming vibes"

Check it out: colorify.rocks

In the pipeline

CSS/SCSS export (because who wants to copy/paste hex codes?)
Tailwind config generation (yes, really!)
API access

Tech stack: Laravel, Tailwind, Livewire, Alpine.js, OpenAI.

What would make this actually useful in your dev workflow? Need specific framework support? Particular export formats?

Discovered - currently not indexed

Job — Tue, 26 Nov 2024 00:30:11 +0000

It’s been two days since I implemented my optimized sitemap strategy for Colorify.Rocks, prioritizing Design-like colors out of the 16 million possible pages. While Google has noticed the sitemap, most pages are still showing the status: "Discovered – currently not indexed."

Understanding "Discovered – Currently Not Indexed"

According to Google, this status means that the page was found but not yet crawled. Google explains this as follows:

The page was found by Google, but not crawled yet. Typically, Google wanted to crawl the URL but this was expected to overload the site; therefore Google rescheduled the crawl. This is why the last crawl date is empty on the report.

My Take on Google's Explanation

While Google's statement suggests that the delay is about protecting your server from overload, I believe that’s not the full story. Yes, Google is concerned about your site’s capacity, but there’s a bigger picture at play: Google’s own crawl budget.

Crawling billions of websites is an expensive process. Even though crawling my pages wouldn’t have a significant impact on Google’s resources, they have to carefully allocate their crawl budget to prioritize content that they believe adds the most value to users.

Here’s my perspective:

Short-Term Delay: If this status appears for a few days, it’s usually fine and part of the normal crawling process.
Long-Term Issue: If the status persists, it may indicate that Google doesn’t currently view the page as valuable or worth prioritizing. That’s when action is needed.

How to Show Google That Your Page Should Be Crawled

If you’re in this situation and want to encourage Google to prioritize crawling certain pages, here are some steps to take:

Eliminate Orphan Pages: Ensure the page isn’t isolated. Add internal links to it from other pages on your site.

If it’s a high-priority page, link to it from your most authoritative pages—those already getting strong attention from Google.

Submit the Page to Google: Use the URL Inspection Tool in Google Search Console to request indexing for individual pages.

This adds the page to Google’s priority crawl queue, giving it a higher chance of being crawled sooner.

Note: You can only submit 10–15 pages per day, so focus on your most important ones.

Enhance Internal Link Strategy: Use descriptive anchor text for links pointing to the page. This helps Google understand its relevance and topic.

Why Focus on Internal Links First?

There are many off-page SEO techniques that can help drive attention to your pages. However, from a purely technical SEO perspective, internal linking and direct submission are two of the fastest, most actionable ways to signal a page's importance to Google.

If you’re seeing “Discovered – currently not indexed,” don’t panic. Use this as an opportunity to refine your internal linking strategy, request indexing for critical pages, and monitor how Google’s crawling evolves.

Remember, it’s a process that takes time. By combining these techniques with consistent monitoring in Google Search Console, you can help Google recognize the value of your content and encourage faster indexing. I’ll continue sharing updates as I gather more insights!

Color Theory: Playing with Colors Programmatically

Job — Sat, 23 Nov 2024 18:55:46 +0000

When I first started building Colorify Rocks, my color palette website, I had no idea how deep the rabbit hole of programmatic color manipulation would go. What started as a simple "let me build a color picker" project turned into a fascinating journey through color theory, mathematical color spaces, and accessibility considerations. Today, I want to share what I learned while building this tool, along with some Python code that might help you in your own color adventures.

It's Just Colors, How Hard Can It Be?

Oh, past me. How naive you were! My journey started with a simple goal: build a website where people could generate and save color palettes. Easy, right? Just grab a hex code and... wait, what's HSL? And why do we need RGB? And what in the world is CMYK?

Want to see what I'm talking about? Check out our color analysis for #3B49DF

Here's the first piece of code I wrote to handle color conversions, which now makes me chuckle at its simplicity:

class Color:
    def __init__(self, hex_code):
        self.hex = hex_code.lstrip('#')
        # Past me: "This is probably all I need!"
    def to_rgb(self):
        # My first "aha!" moment with color spaces
        r = int(self.hex[0:2], 16)
        g = int(self.hex[2:4], 16)
        b = int(self.hex[4:6], 16)
        return f"rgb({r},{g},{b})"

Everything is Math

Then came the moment I realized that colors are basically just math in disguise. Converting between color spaces meant diving into algorithms I hadn't touched since high school. Here's what the code evolved into

def _rgb_to_hsl(self):
    # This was my "mind-blown" moment
    r, g, b = [x/255 for x in (self.rgb['r'], self.rgb['g'], self.rgb['b'])]
    cmax, cmin = max(r, g, b), min(r, g, b)
    delta = cmax - cmin
    # The math that made me question everything I knew about colors
    h = 0
    if delta != 0:
        if cmax == r:
            h = 60 * (((g - b) / delta) % 6)
        elif cmax == g:
            h = 60 * ((b - r) / delta + 2)
        else:
            h = 60 * ((r - g) / delta + 4)
    l = (cmax + cmin) / 2
    s = 0 if delta == 0 else delta / (1 - abs(2 * l - 1))
    return {
        'h': round(h),
        's': round(s * 100),
        'l': round(l * 100)
    }

Colors Have Relationships

One of the most exciting features I built for Colorify Rocks was the color harmony generator. It turns out colors have relationships with each other, just like musical notes! Here's how I implemented color harmonies:

def get_color_harmonies(self, color):
    """
    This is probably my favorite piece of code in the entire project.
    It's like playing with a color wheel, but in code!
    """
    h, s, l = color.hsl['h'], color.hsl['s'], color.hsl['l']
    return {
        'complementary': self._get_complementary(h, s, l),
        'analogous': self._get_analogous(h, s, l),
        'triadic': self._get_triadic(h, s, l),
        'split_complementary': self._get_split_complementary(h, s, l)
    }
def _get_analogous(self, h, s, l):
    # The magic numbers that make designers happy
    return [
        self._hsl_to_hex((h - 30) % 360, s, l),
        self._hsl_to_hex(h, s, l),
        self._hsl_to_hex((h + 30) % 360, s, l)
    ]

Accessibility

The biggest eye-opener came when a user with color blindness submitted feedback. I had completely overlooked accessibility! This led me to implement color blindness simulation:

def simulate_color_blindness(self, color, type='protanopia'):
    """
    This feature wasn't in my original plan, but it became one of
    the most important parts of Colorify Rocks
    """
    matrices = {
        'protanopia': [
            [0.567, 0.433, 0],
            [0.558, 0.442, 0],
            [0, 0.242, 0.758]
        ],
        # Added more types after learning about different forms of color blindness
        'deuteranopia': [
            [0.625, 0.375, 0],
            [0.7, 0.3, 0],
            [0, 0.3, 0.7]
        ]
    }
    # Matrix multiplication that makes sure everyone can use our color palettes
    return self._apply_color_matrix(color, matrices[type])

As Colorify Rocks grew, designers started asking for more features. The big one? Shades and tints of colors. This led to some fun experimentation:

def get_color_variations(self, color, steps=10):
    """
    This started as a simple feature request and turned into
    one of our most-used tools
    """
    return {
        'shades': self._generate_shades(color, steps),
        'tints': self._generate_tints(color, steps),
        'tones': self._generate_tones(color, steps)
    }

Large Sitemaps: 16M Pages Challenge

Job — Wed, 20 Nov 2024 20:43:24 +0000

Colorify.Rocks is a project that generates color palettes and provides a page for every HEX color. Each page includes information like:

Color Values
Complementary Colors
Analogous Colors
Triadic Colors
Shades and Tints
Color Blindness Combinations

With a total of 16 million pages, the challenge is managing such a large number efficiently. While all pages are useful, not all colors are equally important. The goal is to optimize the crawl budget so that search engines focus on the most relevant pages.

Including all 16 million pages in sitemaps would require over 300 files (since each sitemap can hold up to 50,000 URLs).

This approach presents two major issues:

Inefficient Crawling: Search engines might waste time crawling less relevant colors.
Complex Management: Maintaining hundreds of sitemap files is time-consuming and prone to errors.

An optimized solution was necessary to prioritize important pages while still ensuring the rest remain discoverable.

By focusing on Material Design-like colors, I prioritized around 25,000 pages representing a diverse and balanced subset of the color spectrum. For example, shades like #F44336 (a vibrant red) highlight the importance of visually impactful colors frequently used in design systems. These carefully selected pages ensure that the sitemap emphasizes relevance without overwhelming search engines.

Here’s why I didn’t choose other methods:

Web Safe Colors: Only 216 colors, which is far too few for modern use.
Named CSS Colors: About 16 colors, which doesn’t even begin to cover the spectrum.
Pure/Near-Pure Colors: Around 2,000 colors, but these miss subtle and popular shades.
Popular Color Ranges: While ~2.1 million colors cover a broader set, this is still a large number.

By using Material Design-like colors, I created a smaller, more manageable sitemap that still represents a diverse range of colors.

The sitemap doesn’t need to include every page. Each color page links to complementary, analogous, and related colors, allowing search engines to discover the rest of the site naturally.

This way, the sitemap becomes a prioritization tool rather than a full index. Google can focus on the most important pages first, while still crawling the others over time.

Technical Considerations

Including all pages would create more than 300 sitemaps, which is unnecessary for most projects.
A smaller sitemap with ~25,000 pages makes it easier for search engines to focus on high-value content.
Monitoring crawl reports and indexing status helps refine the approach over time.

SEO often requires testing different strategies. This sitemap setup is part of an experiment to see how search engines handle a prioritization-first approach on a large site.

Over time, I’ll adjust based on how Google indexes and crawls the site. It’s about finding the best way to balance efficiency and discoverability.

This approach is just the first step, and I’ll keep refining it as I gather more data. If you’ve dealt with similar challenges, I’d love to hear your thoughts!