Automate Your Job Hunt with Antigravity 2.0 AI Agents

/Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome \
  --remote-debugging-port=9222 \
  --user-data-dir=/Users/yourname/chrome_automation_profile

mkdir -p /Users/yourname/Desktop/Career/auto_jobs/.agents/rules/

---
trigger: always_on
---

# Job Hunt Rules — Always Follow These

## Identity
- The user is an AI/ML Engineer and Full Stack Developer
- Primary email: one@yourname.dev
- Refer to master profile at: profile/master_profile.yaml

## Never Apply Without Checking
1. ALWAYS read profile/master_profile.yaml before applying to any job
2. ALWAYS verify resume PDF is not empty before uploading (open it, read first 3 lines)
3. NEVER apply to a job scoring below 65%
4. NEVER apply to Indian IT services companies (TCS, Infosys, Wipro, HCL, Tech Mahindra, Cognizant)
5. NEVER apply to roles requiring immediate on-site relocation outside India

## Always Log
- Every application attempt MUST be logged to applications.db
- Status must be updated: READY_TO_APPLY → APPLIED → APPLICATION_CONFIRMED
- If a job URL is dead (404), mark status POSITION_CLOSED immediately

## Quality Standards
- Tailor resume for each company — never use the generic master resume directly
- Personalize cover letters with the company's specific product or mission
- Maximum 30 applications per platform per day (avoid bans)

## Before Finishing Any Task
- Update applications.db with the final status of all touched applications
- Export applications.csv from the database
- Notify about total applications submitted today and any errors encountered

mkdir -p /Users/yourname/Desktop/Career/auto_jobs/.agents/skills/job-hunter/

---
name: job-hunter
description: >
  Complete workflow for automated job discovery, scoring, tailored resume generation,
  and application submission across Ashby, LinkedIn, Lever, SmartRecruiters, and
  company career pages. Use this skill whenever the user asks to find jobs, apply to
  jobs, or run the daily job hunt.
---

# Job Hunter Skill

## Step 1: Read Profile
Always start by reading: profile/master_profile.yaml

## Step 2: Discover Jobs
Search these platforms for new jobs matching the target roles:
- https://jobs.ashbyhq.com — search for roles in target_roles list
- https://linkedin.com/jobs — filter by Easy Apply + last 7 days
- https://jobs.lever.co — search for roles
- https://workatastartup.com — filter by Remote

Filter criteria from profile:
- Minimum fit score: minimum_fit_score field
- Exclude companies in: companies_avoid field
- Prefer: company_types_prefer field

## Step 3: Score Each Job
For each job found:
1. Read the full job description
2. Compare against skills, experience, and preferences in profile.yaml
3. Assign a score 0-100
4. Save to applications.db with status READY_TO_APPLY if score >= minimum_fit_score

## Step 4: Tailor Resume
For each job that passes scoring:
1. Read master resume at resume/master_resume.docx
2. Read the job description
3. Generate a tailored 1-page ATS resume
4. Save as resume/tailored/[COMPANY]_[ROLE].pdf
5. VERIFY: open the PDF and confirm it has content (not empty)

## Step 5: Apply
For each READY_TO_APPLY job with a verified resume:
1. Navigate to the job application page
2. Fill all form fields from profile.yaml
3. Upload the tailored resume
4. Submit the form
5. Update applications.db: status = APPLIED, date_applied = today
6. If application confirmed: update status = APPLICATION_CONFIRMED

## Step 6: Outreach (if apply not possible)
If a job has no direct application form:
1. Find recruiter/hiring manager on LinkedIn
2. Draft personalized outreach using cover_letters/template_cold_email.txt
3. Send via Gmail using credentials in .env
4. Log outreach to applications.db

## Step 7: Summary
At the end of every run, provide:
- Total new jobs found
- Total applied
- Total confirmed
- Any errors or issues encountered
- Top 3 applications by fit score

@profile/master_profile.yaml Find me AI Engineer jobs on Ashby and apply

@applications.db @resume/master_resume.pdf 
What's my current application status and which resume should I use next?

@.agents/rules/job_hunt_rules.md 
Confirm you've read my rules before starting today's job hunt

Good morning! Run today's full job hunt. Use the job-hunter skill.

Platform priority:
1. Ashby (jobs.ashbyhq.com) — AI startups, YC companies
2. Work at a Startup (workatastartup.com) — Series A/B remote roles
3. LinkedIn (Easy Apply) — roles posted in last 24 hours
4. Lever (jobs.lever.co) — check last 3 days

Target roles: AI/ML Engineer, Full Stack AI Engineer, LLM Engineer, Forward Deployed Engineer
Minimum fit score: 70%

After finding and scoring all jobs:
- Show me the list with scores BEFORE applying
- Wait for my approval before submitting applications

Then after I approve:
- Tailor resume for each (verify PDFs are not empty!)
- Submit applications
- Log everything to applications.db
- Export applications.csv
- Give me final summary

Run today's full job hunt with the job-hunter skill.
Full auto mode — find, score, tailor, apply without waiting for my review.
Minimum score: 75%. Max 25 applications today.
Use /goal to ensure you don't stop until the target is reached.

Check my job hunt status:
1. Read applications.db
2. Show me a breakdown: Applied / Confirmed / Interview / Rejected
3. Flag any applications older than 7 days with no response (need follow-up)
4. Any interviews this week?
5. Sync to Google Sheet [YOUR-SHEET-ID]

Check applications.db for jobs I applied to 5-7 days ago with no response.
For each, find the recruiter or hiring manager on LinkedIn.
Draft and send personalized follow-up emails via Gmail.
Update next_follow_up dates in the database.

I want to search 4 job boards simultaneously today. Spawn 4 subagents:

Subagent 1 — Ashby Hunter:
Search jobs.ashbyhq.com for AI/ML Engineer and LLM Engineer roles posted this week.
Score each against profile/master_profile.yaml. Save results to applications.db.
Report back: total found, top 5 by score.

Subagent 2 — LinkedIn Hunter:
Search linkedin.com/jobs for Easy Apply AI Engineer roles in last 24 hours.
Filter: Remote preferred, score >= 70%. Save to applications.db.
Report back: total found, top 5 by score.

Subagent 3 — YC/Startup Hunter:
Search workatastartup.com for Remote AI/ML roles at Series A-B companies.
Score >= 70%. Save to applications.db.
Report back: total found, top 5 by score.

Subagent 4 — Lever Hunter:
Search jobs.lever.co for Full Stack AI Engineer roles.
Score against profile. Save to applications.db.
Report back: total found, top 5 by score.

Once all 4 report back, I'll review the combined results and tell you which to apply to.

I have 20 READY_TO_APPLY jobs in applications.db. Spawn 4 subagents to apply in parallel:

Subagent 1: Apply to jobs from source = 'ashby' (limit 5)
Subagent 2: Apply to jobs from source = 'linkedin' (limit 5)
Subagent 3: Apply to jobs from source = 'lever' (limit 5)
Subagent 4: Apply to jobs from source = 'workatastartup' (limit 5)

Each subagent:
- Reads the specific job entry from applications.db
- Tailors resume (saves as resume/tailored/[company]_[role].pdf)
- Verifies PDF is not empty
- Submits the application
- Updates applications.db status = APPLIED
- Reports back when done

Wait for all 4 to finish, then give me the consolidated summary.

Spawn 2 specialized subagents:

Subagent A — Resume Tailor:
For every READY_TO_APPLY job in applications.db (score >= 70%):
- Read master resume at resume/master_resume.docx
- Read each job description URL
- Generate tailored 1-page ATS resume
- Save to resume/tailored/[company]_[role].pdf
- Verify PDF is not empty
- Update database field: resume_version = path to tailored PDF
- Report when ALL resumes are ready

Subagent B — Applier (waits for Subagent A):
After Subagent A reports all resumes ready:
- For each READY_TO_APPLY job where resume_version is filled:
- Navigate to application URL
- Fill form from profile/master_profile.yaml
- Upload the tailored resume
- Submit
- Update status = APPLIED

Name: Daily Job Hunt
Cron: 0 8 * * *   (every day at 8 AM)
Prompt: Run today's full job hunt using the job-hunter skill.
Find all AI/ML Engineer jobs posted in the last 24 hours on Ashby, LinkedIn, Lever,
and Work at a Startup. Score each against profile/master_profile.yaml.
Apply to all scoring >= 70%. Log to applications.db. Export applications.csv.
Send Telegram notification with daily summary.
Project: Job Hunt Automation

Name: Evening Sheets Sync
Cron: 0 21 * * *   (every day at 9 PM)
Prompt: Read applications.db and sync all application data to Google Sheet
[YOUR-SHEET-ID]. Replace current data, freeze header row. Apply color coding:
green=confirmed, yellow=interview, red=rejected, blue=applied.
Project: Job Hunt Automation

Name: Interview Email Parser
Cron: 0 10,18 * * *   (10 AM and 6 PM daily)
Prompt: Check my Gmail for any emails received in the last 6 hours containing:
interview, schedule, assessment, coding test, take-home, Zoom, Google Meet, Teams.
For each found: create a Google Calendar event, update applications.db status,
send Telegram notification: "INTERVIEW at [COMPANY] on [DATE] [TIME] — [LINK]"
Project: Job Hunt Automation

Name: Weekly Follow-Up Sender
Cron: 0 10 * * 1   (every Monday at 10 AM)
Prompt: Check applications.db for jobs applied 5-10 days ago with no response.
For each, find recruiter on LinkedIn. Draft and send personalized follow-up email
via Gmail. Update next_follow_up date in database. Send me a Telegram summary
of how many follow-ups were sent.
Project: Job Hunt Automation

Name: Weekly Job Cleanup
Cron: 0 9 * * 0   (every Sunday at 9 AM)
Prompt: Check applications.db for all READY_TO_APPLY jobs.
Visit each job URL and verify it is still active.
If 404 or "position closed" → update status = POSITION_CLOSED.
Generate a weekly summary: total applied this week, response rate, top companies.
Project: Job Hunt Automation

/schedule in 2 hours: Check my Gmail for any new interview invitations and
create Calendar events for each one found.

/schedule tomorrow 8 AM: Run the full job hunt for today — Ashby + LinkedIn
+ Lever. Apply to all matches >= 75%.

Connect to my Google Sheet [YOUR-SHEET-ID] and update it with
current data from applications.db. Add a row for every new application
since the last sync.

Using the Gmail MCP connection, search my inbox for emails in the last 
24 hours with subject containing "application received" OR "we received your"
OR "thank you for applying". For each, update the matching application in
applications.db to status = APPLICATION_CONFIRMED.

Create a Google Calendar event:
- Title: "Interview — [COMPANY] [ROLE]"
- Date: [DATE]
- Time: [TIME IST]  
- Location: [MEETING_LINK]
- Description: [JOB_URL]
- Reminders: 1 hour and 1 day before

{
  "mcpServers": {
    "job-tracker": {
      "command": "python3",
      "args": ["/Users/yourname/Desktop/Career/auto_jobs/engine/mcp_server.py"],
      "description": "Custom job tracking MCP server with direct SQLite access"
    },
    "telegram-notifier": {
      "command": "node",
      "args": ["/Users/yourname/Desktop/Career/auto_jobs/engine/telegram_mcp.js"],
      "description": "Sends Telegram notifications for job hunt events"
    }
  }
}

pip install google-antigravity

#!/usr/bin/env python3
"""
Trigger an Antigravity agent to run today's job hunt.
Can be called from cron, GitHub Actions, or any other scheduler.
"""
import asyncio
import sys
from google.antigravity import Agent, LocalAgentConfig, CapabilitiesConfig

DAILY_JOB_HUNT_PROMPT = """
Run today's full job hunt using the job-hunter skill.

Steps:
1. Read profile/master_profile.yaml
2. Search Ashby, LinkedIn (Easy Apply), Lever, Work at a Startup
3. Score each job against my profile (minimum 70%)
4. Tailor resume for each match (verify PDF not empty)
5. Apply to all matches >= 70%
6. Log everything to applications.db
7. Export applications.csv
8. Send Telegram notification with summary

Do not stop until all jobs are processed. Report the final count.
"""

async def run_job_hunt():
    config = LocalAgentConfig(
        system_instructions="""
        You are an expert job hunt automation agent.
        Always read profile/master_profile.yaml before any job search.
        Never apply to Indian IT services companies.
        Always verify resume PDFs are not empty before uploading.
        Log every action to applications.db.
        """,
        capabilities=CapabilitiesConfig(),  # Full capabilities: run commands, edit files, browse
        workspace="/Users/yourname/Desktop/Career/auto_jobs"
    )

    async with Agent(config) as agent:
        print("Starting job hunt agent...")

        response = await agent.chat(DAILY_JOB_HUNT_PROMPT)

        # Stream the agent's output in real time
        async for token in response:
            sys.stdout.write(token)
            sys.stdout.flush()

        # Also stream its reasoning (optional)
        async for thought in response.thoughts:
            print(f"\n[Agent thinking] {thought[:100]}...")

        print("\n\nJob hunt complete!")


if __name__ == "__main__":
    asyncio.run(run_job_hunt())

#!/usr/bin/env python3
"""
Spawn multiple job hunt agents in parallel using the SDK.
"""
import asyncio
from google.antigravity import Agent, LocalAgentConfig, CapabilitiesConfig

WORKSPACE = "/Users/yourname/Desktop/Career/auto_jobs"

BASE_SYSTEM = """
You are a specialized job hunt agent. 
Always read profile/master_profile.yaml first.
Never apply to Indian IT services companies.
Always verify resume PDFs before uploading.
Log all results to applications.db.
"""

async def hunt_platform(platform_name: str, prompt: str) -> str:
    """Run a single platform's job search agent."""
    config = LocalAgentConfig(
        system_instructions=BASE_SYSTEM,
        capabilities=CapabilitiesConfig(),
        workspace=WORKSPACE
    )
    async with Agent(config) as agent:
        response = await agent.chat(prompt)
        result = ""
        async for token in response:
            result += token
        print(f"[{platform_name}] Done")
        return result


async def main():
    """Spawn 4 platform agents in parallel."""

    ashby_prompt = """
    Go to https://jobs.ashbyhq.com and search for:
    - AI Engineer
    - LLM Engineer  
    - Forward Deployed Engineer
    Filter: posted this week. Score each against profile/master_profile.yaml.
    Save all scoring >= 70% to applications.db with status READY_TO_APPLY.
    Return: total found, total qualifying, top 3 by score.
    """

    linkedin_prompt = """
    Go to https://linkedin.com/jobs and search for AI Engineer with Easy Apply filter.
    Filter: posted last 24 hours, Remote preferred.
    Score each against profile/master_profile.yaml.
    Save all scoring >= 70% to applications.db with status READY_TO_APPLY.
    Return: total found, total qualifying, top 3 by score.
    """

    yc_prompt = """
    Go to https://workatastartup.com and search for AI/ML Engineer roles.
    Filter: Remote, Series A-B companies.
    Score each against profile/master_profile.yaml.
    Save all scoring >= 70% to applications.db with status READY_TO_APPLY.
    Return: total found, total qualifying, top 3 by score.
    """

    lever_prompt = """
    Go to https://jobs.lever.co and search for Full Stack AI Engineer.
    Score each against profile/master_profile.yaml.
    Save all scoring >= 70% to applications.db with status READY_TO_APPLY.
    Return: total found, total qualifying, top 3 by score.
    """

    print("Launching 4 parallel job hunt agents...")
    print("="*60)

    # Run all 4 agents simultaneously
    results = await asyncio.gather(
        hunt_platform("Ashby", ashby_prompt),
        hunt_platform("LinkedIn", linkedin_prompt),
        hunt_platform("YC/Startup", yc_prompt),
        hunt_platform("Lever", lever_prompt),
        return_exceptions=True  # Don't crash if one agent fails
    )

    print("\n" + "="*60)
    print("ALL AGENTS COMPLETED")
    print("="*60)

    for platform, result in zip(["Ashby", "LinkedIn", "YC", "Lever"], results):
        if isinstance(result, Exception):
            print(f"\n[{platform}] ERROR: {result}")
        else:
            print(f"\n[{platform}] Summary:\n{result[:500]}")


if __name__ == "__main__":
    asyncio.run(main())

async with Agent(config) as agent:
    response = await agent.chat(prompt)

    # Watch exactly what the agent does, step by step
    async for call in response.tool_calls:
        if call.name == "run_command":
            print(f"Running: {call.args.get('CommandLine', '')[:80]}")
        elif call.name == "view_file":
            print(f"Reading: {call.args.get('AbsolutePath', '')}")
        elif call.name == "write_to_file":
            print(f"Writing: {call.args.get('TargetFile', '')}")
        else:
            print(f"Tool: {call.name}")

Project path: /Users/yourname/Desktop/Career/auto_jobs
Settings: Internet=allow, Files=allow, Auto-execute=proceed-in-sandbox

Create the file .agents/rules/job_hunt_rules.md with my job hunting rules.
Include: never apply below 65% score, never apply to Indian IT services companies,
always verify PDF before uploading, always log to applications.db,
always read profile/master_profile.yaml before starting any job search.

Create the file .agents/skills/job-hunter/SKILL.md with a complete job hunter
skill workflow: discover → score → tailor resume → verify PDF → apply → log → report.

Create profile/master_profile.yaml with my complete profile.
[Paste your profile details from the first guide]

Create a shell script at engine/start_chrome.sh that launches Chrome with
--remote-debugging-port=9222 and a persistent user-data-dir.
Make it executable. Add it to the Command Allowlist in Antigravity Settings.

Run a test with just 3 applications: Search Ashby for AI Engineer.
Find the top 3 results. Tailor resume for each. Submit 1 application (ask me
which one before submitting). Log to applications.db. Show me the result.

/goal

Find and apply to 20 new AI Engineer jobs today.
Platforms: Ashby (priority 1), LinkedIn Easy Apply (priority 2), Lever (priority 3).
Score >= 70%. Tailor resume for each. Verify PDFs. Submit all.
Do not stop until 20 applications are submitted or you have exhausted all matching jobs.
Log everything to applications.db. Send Telegram summary at the end.

/goal Apply to 15 AI Engineer jobs on Ashby today, minimum 70% fit score

/schedule tomorrow 6 AM: Run the weekly follow-up on all applications 
older than 7 days. Send me a Telegram summary.

/boost Analyze all my rejected applications in applications.db and identify 
patterns — why am I being rejected? What should I improve in my profile or resume?

/learn Never apply to companies that are in the cryptocurrency/web3 space.
Always check if a company's product is crypto-related before applying.

/teamwork-preview I need a team to: 
(1) find jobs on 5 platforms simultaneously
(2) research each company's tech stack and culture
(3) tailor my resume for each
(4) apply to all matches
Do all of this in parallel.

Auto-Execution Policy: proceed-in-sandbox
→ Most commands run automatically. Good balance of speed and safety.

Internet Access Policy: allow
→ Agent needs to browse job sites without asking each time.

Command Allowlist:
- python3 engine/
- node engine/
- pdftotext resume/
- /Applications/Google Chrome.app (for Chrome launch)
- sqlite3 applications.db

Command Denylist:
- rm -rf
- DROP TABLE
- git push (prevent accidental repo pushes)

Browser Allowlist:
- jobs.ashbyhq.com
- linkedin.com
- jobs.lever.co
- workatastartup.com
- careers.smartrecruiters.com
- boards.greenhouse.io
- glassdoor.com
- google.com (for Sheets/Gmail/Calendar)
- wellfound.com

File Access Grants:
- /Users/yourname/Desktop/Career/auto_jobs/** (full access to project)
- /Users/yourname/chrome_automation_profile/** (Chrome profile)

The CDP connection is failing. Run this command to verify Chrome is ready:
curl http://localhost:9222/json
If it fails, help me launch Chrome with the correct flags.

First, ensure Chrome is running with CDP. Run:
/Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome --remote-debugging-port=9222 --user-data-dir=/Users/yourname/chrome_automation_profile &
Wait 3 seconds for Chrome to start.
Then proceed with the job hunt.

If you encounter any error, do NOT stop silently.
Report the exact error message back to the main conversation.
Then try to continue with the next job.

Before applying to any job, ALWAYS check applications.db first.
If a job URL already exists in the database with status APPLIED or
APPLICATION_CONFIRMED, skip it — do not apply again.

@resume/master_resume.pdf @profile/master_profile.yaml 
Generate a tailored resume for this job: [JOB_URL]

Here are the jobs I found manually today. Score each and apply to matches >= 70%:
1. https://jobs.ashbyhq.com/livekit/engineer
2. https://jobs.lever.co/langchain/ml-engineer
3. https://boards.greenhouse.io/company/role

/learn You applied to a Web3 company. I never want to work in crypto or Web3.
Before applying to any company, check if their product involves blockchain,
cryptocurrency, NFTs, or DeFi. If yes, skip immediately.

Before applying to [COMPANY], spawn a research subagent to:
1. Check if the company is still active (has recent news/posts)
2. Find the tech stack from their job postings and GitHub
3. Find any employee reviews on Glassdoor (rating > 3.5?)
4. Find 1-2 specific things I can reference in my cover letter
5. Report back with a "Company Brief" before I write the cover letter

/boost Analyze my applications.db from this week.
- Which platforms had the highest confirmation rate?
- Which job titles had the best response rate?
- What did the confirmed applications have in common (company size, tech stack, role type)?
- What should I target more vs. less next week?
- Suggest 3 specific changes to my profile/master_profile.yaml.

Spawn a subagent to prepare me for my interview at [COMPANY] for [ROLE] on [DATE].

Research:
- Company's product, mission, recent news
- Their tech stack (from GitHub, job posts)
- Common questions for this role type

Generate:
- 10 likely technical questions with my STAR-format answers
- 5 behavioral questions with answers from my experience
- 3 smart questions I should ask them

Save to applications/interview_prep_[COMPANY]_[DATE].md

I want to A/B test two resume versions.
For the next 10 applications:
- Odd-numbered applications: use resume/variant_A.pdf
- Even-numbered applications: use resume/variant_B.pdf

Log which variant was used in the resume_version column in applications.db.
After 2 weeks, I'll ask you to compare response rates between A and B.

AUTOMATED (Antigravity does this while you sleep or work):
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
8:00 AM  → Daily Job Hunt (find + score + tailor + apply)
10:00 AM → Email Check (parse for interview invites → Calendar events)
9:00 PM  → Sheets Sync (database → Google Sheets with colors)
10:00 PM → Email Check again (catch anything from the afternoon)
Monday   → Weekly Follow-Up (send emails to non-responders)
Sunday   → Weekly Cleanup (close dead job links, generate report)

MANUAL (you do this, takes ~15 minutes):
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Morning  → Glance at Telegram for today's summary
Anytime  → Review Google Sheets for status updates
When you get interviews → Run interview prep subagent
Weekly   → /boost analysis — adjust strategy based on conversion rates