Autumn recruitment info is too scattered, so I used AI to build a website that solves it perfectly.

Hi everyone, I’m luckySnail. The autumn recruitment season is almost here. I wonder how you’re all finding jobs these days? Back in my day, I used to look for work on job boards like BOSS Zhipin. Occasionally, someone would share an internal referral in a group chat, or I’d submit my resume directly through a company’s official website. But in the AI era, I’ve noticed that a lot of AI startups and big companies prefer to recruit directly on social media—DeepSeek is a recent example. This is a great opportunity for students with more average academic backgrounds, because many job postings are shared directly by company owners or project leads. If you apply, your resume goes straight to them. On a platform like BOSS Zhipin, though, if your academic background isn’t impressive, your resume might get filtered out by the system before anyone even sees it.

Besides, in the AI era, a resume alone doesn’t say much anymore. If you want to find standout candidates, social media might be a better way to go. That’s why new job postings show up every day on platforms like Xiaohongshu and X. If you can spot them and apply quickly, that’s a big deal for anyone seriously looking for work.

That said, while these platforms have plenty of openings, figuring out which ones fit your needs—and whether they’re legit—still takes a lot of time. Unlike BOSS Zhipin, where companies have to meet certain requirements to post, there’s no such filter here. So I started thinking: could I build a tool that automatically scrapes the jobs I need, assesses how reliable each posting is, and helps me manage my applications? After all, job hunting and interview prep are already exhausting. Spending hours on top of that just to sift through posts isn’t worth it.

That’s how jobhub came about. It automatically collects the latest job postings from Xiaohongshu and X, lets you filter by your criteria to find the roles you want, and then lets you view, apply, track your applications, and manage your interview progress.

How the Site Was Built

Below I’ll walk through how I built this little tool step by step using vibe coding. This time I used the doubao seed model combined with omp (Oh My Pi). First, let’s look at how to install the omp harness and how to connect doubao-seed-evolving to it.

OMP (Oh My Pi): An enhanced development environment built on the Pi Coding Agent, making Pi more suitable for everyday AI coding through plugins, workflows, and multi-model support.

1. Prerequisites

1. omp installed (check locally with omp --version)
2. A doubao Agent Plan with an API Key
3. Environment variable configured (recommended to add to ~/.zshenv or ~/.omp/.env):

export ARK_API_KEY="your Ark API Key"

2. Writing the omp Configuration

This model has a 1M context window. Let’s edit (or create) ~/.omp/agent/models.yml:

providers:
  doubao:
    baseUrl: https://ark.cn-beijing.volces.com/api/plan/v3
    api: openai-responses
    apiKey: ARK_API_KEY
    models:
      - id: doubao-seed-evolving
        name: Doubao Seed Evolving
        reasoning: true
        input: [text, image]
        contextWindow: 1048576
        maxTokens: 65536
        supportsTools: true
        cost:
          input: 0
          output: 0
          cacheRead: 0
          cacheWrite: 0
        compat:
          supportsStore: false
# Anthropic Messages API
  doubao-anthropic:
    baseUrl: https://ark.cn-beijing.volces.com/api/plan
    api: anthropic-messages
    apiKey: ARK_API_KEY
    disableStrictTools: true
    models:
      - id: doubao-seed-evolving
        name: Doubao Seed Evolving (Anthropic)
        reasoning: true
        input: [text, image]
        contextWindow: 1048576
        maxTokens: 65536
        supportsTools: true
        cost:
          input: 0
          output: 0
          cacheRead: 0
          cacheWrite: 0

Here apiKey: ARK_API_KEY pulls from the environment variable we just set. supportsStore: false is because third-party gateways generally don’t support OpenAI’s store/state chaining. Then we can set doubao as the default model:

omp config set modelRoles '{"default":"doubao/doubao-seed-evolving"}'

Now we can verify and start using it:

Launch it with omp and you’re ready to go:

3. Setting Up the Project Skeleton

The first thing we need to do is scaffold the project structure. This step is critical, because how smoothly the AI development goes from here depends entirely on it. Our tech stack choices need to be very mainstream, and we should stick to common patterns in the implementation as well. These choices aren’t really about serving developers — they’re about making it easier for the AI to do a good job.

After 17 minutes, it finally finished. It built the frontend first, then the backend, and finally integrated orpc — looks good.

I started it up to confirm both the frontend page and backend APIs were working, then had my gpt-5.6-sol review the code. It flagged a few minor issues.

4. Verifying the Core Capability

Next comes the moment of truth: can the most important feature of this product actually work? If the core capability can’t be implemented, everything we’ve done so far is wasted. That’s why this step has to happen early. Our core feature is scraping job postings from Xiaohongshu and Twitter, then automatically organizing and displaying them.

Here I used the /prototype skill from matt skills. This skill is specifically designed to help you validate whether an idea is feasible. As you can see, the verification succeeded — it was able to scrape the relevant data.

5. Building the MVP

Now it’s time to develop the product demo. The core goal here is to turn the validated capability into an actual product — something that’s genuinely usable. This was a fairly long task, and my prompt was relatively detailed and professional. I was hoping these constraints would let it build the whole feature in one shot.

Let’s see what it produced!

Surprisingly, it worked on the first try. You can see it already scraped some data for us. Clicking on a job posting shows the full details.

But I noticed a couple of issues: first, it didn’t scrape any data from Xiaohongshu, and second, the display quality was pretty poor. So let’s polish things up.

6. Iterating on Bugs and Polishing the Product

I stayed in the same conversation thread for this. The optimization process is pretty straightforward: keep testing, find issues, describe them to the AI, let the AI fix them, test again — repeat until the product reaches the state we want. The final result after optimization is what you saw at the beginning of this post. The job list looks like this:

Job details:

Instead of storing and displaying the scraped content directly, I added an AI analysis step to process and reformat the data for easier browsing.

7. Daily Auto-Scraping with Email Notifications

For job hunting, being the first to know about new postings is crucial. So once we have the data, getting it to me quickly matters just as much — I don’t want to passively visit the page to check for updates. Now I’m adding a subscription feature to the system that automatically notifies users of newly posted jobs, so they can get their resumes to recruiters as soon as possible.

The implementation is simple: whenever a new relevant job appears, an email goes out to the subscribed user. Here’s what it looks like:

Once subscribed, every new job opportunity triggers an email to my inbox.

One thing worth calling out: doubao seed’s 1M context window is genuinely impressive. I never hit context compression during development — the entire product was built in a single conversation. It’s especially well-suited for long-horizon tasks.

Finally, the site is live at https://jobhub.islumi.com/ and the source code is open-sourced:

Feel free to check it out. Contributions and remixes are welcome!

Summary

That’s the whole story of how I ran into a problem, turned it into a product, and used it to solve it. If you’ve hit similar issues, consider building your own solution the same way. With AI in the picture, the cost of turning a problem into a product has shifted from development effort to attention and initiative—plus, of course, your tokens. Here are some lessons learned from building this product, recapped:

• Tech stack choice: Pick AI-friendly technologies, ideally ones with as much documentation as possible. The richer the training corpus for large models, the better the AI-generated output will be.
• Validate the core capability first: Before diving into real development, have AI quickly verify that the core capability is actually feasible. Otherwise, you might get halfway through, hit a dead end, and all the work you’ve done goes to waste.
• Set constraints: AI is already extremely capable, so we’re increasingly handing it long-horizon tasks. In that context, defining clear constraints upfront is critical to keep it from drifting further and further in the wrong direction.
• Keep broadening and deepening your own knowledge: Building this product wasn’t particularly hard, but it still required a solid knowledge base. Without it, you can get stuck on certain issues and stall out. So in the AI era, investing in yourself still matters.

Thanks for reading this far. If this post helped you, a like and a follow would mean a lot—it keeps me motivated to create more.