A few months ago, a close friend of mine lost his job. The kicker? He wasn't just laid off; he was essentially replaced by an AI programming agent. It was a wake-up call. I wanted to understand exactly where my own profile fit in this rapidly shifting market, but the manual process of searching and applying is a soul-crushing grind.
At the same time, my day job involved a lot of work with browser automation and form-filling. I realized I could combine these two worlds.
The result is HuntOS: a local-first, automated job application tool. But the real story isn't just what it does—it's how it was built.
The $10 Stack: Vibe Coding into Reality
This project is a testament to how "vibe coding" has changed the game. I built HuntOS with just a $10 GitHub Copilot subscription, the Zed editor, and a dream.
When I say I "built" it, I mean I didn't manually write a single line of code.
Using the AI features in Zed, I acted more like a systems architect than a coder. I provided the high-level design, described the infrastructure, and let the agents do the heavy lifting. I primarily used Claude 3.5 Sonnet for the bulk of the logic and Claude 3 Opus for the more complex architectural puzzles.
Even the logo you see at the top of the README? That was vibe-coded as an SVG. I described the look I wanted, and the agent generated the math and the tags.
The Recipe: How to Replicate This Success
If you want to build something similar, here is the "cooking recipe" I followed. It’s less about syntax and more about managing context:
The Blueprint: I started with a high-level DESIGN.md. This served as the source of truth for the entire system.
The Specs: From that blueprint, I generated individual technical specs inside a Design folder. Each file focused on a specific sub-system.
The Agents: For every new feature, I created a new Zed Agent.
Context Management: I grouped similar features into the same chat histories. When a chat reached its context limit, I would have the agent summarize the current state, start a new agent session with that summary, and continue. This kept the "brain" focused on the task at hand without getting lost in the noise of unrelated features.
The Workflow: This following video perfectly encapsulates the workflow I used. Even though I didn't see it until after I started, it’s a great visual guide for this style of development.
The most shocking part? The total time investment was about 2 weeks with multiple gaps. In reality, it was roughly 4 days of work, 2 hours per day. That’s 8 hours to go from a dream to a working automated job application OS.
What is HuntOS?
HuntOS is designed to be your personal career command center. It handles the tedious parts of the job search so you can focus on the interviews.
- Job Board Scraping: It pulls listings from LinkedIn, Greenhouse, and others.
- Tailored Resumes: It uses agents to generate Markdown and PDF resumes specifically for each job description.
- Browser Automation: Using Chrome DevTools Protocol (CDP), it actually navigates to the forms and fills them out.
- Audit Trails: It takes screenshots of every step the agent takes, so you can see exactly what happened during an automated application.
PS: I don't speak german but added that to my profile anyways.
Performance: How Good is the Agent?
Since I didn't write the code, I have to judge the agent as if it were a junior developer I hired.
Code Quality
Note: I am still looking into the best ways to quantitatively measure this. Some strategies I'm considering are running complexity analysis, looking at test coverage (which the agent also has to write!), and using automated linting tools to see how "clean" the output is. For now, the "vibe" is that it is surprisingly modular.
Project Quality
The agent exceeded my expectations in several areas:
Resume Generation: It correctly identified my most relevant projects and experience, perfectly adhering to the Markdown templates I provided.
Job Discovery: It successfully scraped positions based on my specific preferences like location, compensation, and role type.
Submission Rate: I’ve achieved a 65% successful submission rate so far.
The "Rough Edges": It’s not perfect. It still struggles with sites that require a login or have very strict form validation. Interestingly, using
Qwen 3.5 A30B, I noticed it would occasionally try to type "Two" into a field that expected an integer. Also, the screenshot logic isn't 100% accurate yet, so some logs are a bit fuzzy.
High Tech, Low Cost
One of my main goals was to keep the project accessible. We use a "local-first" approach:
- SQLite for all data storage (no expensive cloud DBs).
- Self-hostable models: It supports Ollama and LMStudio, meaning you can run the "brains" of the operation on your own hardware.
- Smart Model Routing: You can use cheaper models for simple tasks and save the "expensive" tokens for the complex reasoning.
The Bill: What did this actually cost?
To go from an empty folder to a fully functional, agent-driven OS, the financial investment was minimal:
- GitHub Copilot Subscription: $10 (The primary "engine" for the Zed agents).
- LLM API Costs: ~$0 (By using self-hostable models and free-tier/low-cost tokens).
- Manual Labor: $0 (Zero lines of code written by hand).
- Electricity: TBD (My roommates haven't seen the bill yet, but my GPU fans were spinning so fast I’m pretty sure the living room hovered a few inches off the ground).
Seriously, the marginal impact on the electricity bill is probably the most expensive part of the stack, and even then, I'm splitting it three ways. Sorry guys.
The "Agentic" Shift
Building HuntOS showed me just how strong AI agents have become. We are reaching a point where the barrier between an idea and a working prototype is thinner than ever.
The shift in programming paradigms reminds me of how we moved from manual "stick shift" vehicles to automatic ones. In the past, you had to be intimately involved in every gear change—writing every line of code by hand. Now, we are moving toward an "automatic" experience where the AI handles the mechanics of the transmission. You still need to know how to drive, where you're going, and when to hit the brakes, but you aren't bogged down by the manual labor of the gearbox.
We still need a "driver" for now, but I can see a future where "Full Self-Driving" for software becomes a reality. In that world, the only real contribution from the human "driver" is to decide which destination actually generates the most value.
How to use HuntOS
If you want to try this out yourself, here is the quick-start guide:
- Install Bun: Ensure you have the
bunruntime installed locally. - Install Chrome: You’ll need
google-chrome-stablefor the browser automation. - Start it up: Run the
bun startscript. You should see a Chrome instance launch. - Login: In that specific Chrome instance, log in to your LinkedIn account.
- Navigate: Go to the HuntOS landing page in your local browser and follow the onboarding instructions.
The "Agentic" Shift
However, this experience also taught me that software engineering isn't dead—it's evolving.
While I didn't write the lines of code, I had to spend a lot of time thinking about infrastructure, data flow, and how to prompt the agents effectively. You still need to understand the "why" behind the code to debug issues and maintain a coherent architecture. You have to guide the "vibe" so the project doesn't turn into a spaghetti mess.
Open Sourcing the Dream
I’m excited to announce that HuntOS is now open source. I invite individual contributors to help expand on the functionalities of the software and make into something practical that people can actually use. (Also I ran out of credits so....)
The License: I’ve released this under a license that ensures it stays free for individuals. It should not be used for profit or by companies looking to charge for these tools. This is by the people, for the people.
You can find the project here:
Blakeinstein
/
HuntOS
Tool to auto apply to jobs
HuntOS
Automated job application OS — powered by AI agents, browser automation, and a fully local stack.
What is HuntOS?
HuntOS is a local-first, agent-driven job application platform. It combines a SvelteKit UI, Mastra AI agents, and Chrome DevTools Protocol automation to research job listings, tailor resumes, and submit applications — while you focus on what matters.
Capability
Details
Job board scraping
LinkedIn, Greenhouse, and generic boards
Resume generation
Agent-tailored Markdown + PDF per application
Browser automation
Full CDP-driven form filling and submission
Kanban pipeline
Track every application from research to offer
Audit trail
Per-run annotated screenshots and action logs
Fully local
SQLite databases, no cloud storage required
Usage Guide
-
Install Bun: Ensure you have the
bunruntime installed locally. -
Install Chrome: You’ll need
google-chrome-stablefor the browser automation. -
Start it up: Run the
bun startscript. You should see a Chrome instance launch. - Login: In that specific Chrome instance…
Final Thoughts
We live in a world where AI can take jobs, but it can also give us the tools to find new ones faster than ever. HuntOS started as a way to help a friend and understand the market, but it turned into a lesson in the power of modern development.
Whether you're a seasoned engineer or someone with just an idea, the tools are there. All you need is a few dollars and the right prompts.
Happy hunting!
Top comments (1)
I am planning to do a second exploration into understanding more complex and costly workflows, especially things like Ralphex to understand whether there is value in a fully autonomous workflow.