agentleFS
galiprandigaliprandi/job-seeker/.agents/skills/targets/SKILL.md

targets

Skill136 starsChanged 3 days agoMITView on GitHub

Active direct sourcing. Registers and creates standout profiles on the 40 target companies' career sites, then applies to matching positions.

The file

Show its rules and text

We split this skill into the rules it gives an agent

36 rules. About 0 are common, 21 are distinctive, and 15 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈21

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 15

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    Before applying to any job, verify against Must-haves from users.data.job_preferences.

    line 46
  2. Very specific:

    Not in user's accepted locations (per location and timezones preferences)

    line 53
  3. Distinctive:

    Detect ATS: if not already identified.

    line 64
  4. Very specific:

    If no account creation possible → mark registration_status = 'manual_login_needed', notify user (Gold Rule 5)

    line 83
  5. Distinctive:

    Subscribe to job alerts: if the ATS or career site supports it.

    line 100
  6. Distinctive:

    Greenhouse: look for "Subscribe to alerts" or "Email me new jobs" link on the job board.

    line 101
  7. Distinctive:

    Lever: look for "Subscribe" or "Alerts" button.

    line 102
  8. Distinctive:

    Ashby: look for "Subscribe to alerts" link.

    line 103
  9. Distinctive:

    Workable: look for "Subscribe" or "Job Alerts" link.

    line 104
  10. Distinctive:

    SmartRecruiters: look for "Job Alerts" or "Subscribe" link.

    line 105
  11. Distinctive:

    Teamtailor: look for "Subscribe" or "Alerts" link.

    line 106
  12. Very specific:

    Custom ATS: look for any "Subscribe", "Alerts", "Notify me", or RSS feed icon.

    line 109
  13. Very specific:

    Email: use the user's email (from users.data.profile.email) so alerts route through the Gmail filter

    line 112
  14. Distinctive:

    Update DB with alert status:

    line 113
  15. Distinctive:

    If alerts not available on the platform, note it:

    line 117
  16. Very specific:

    Check dedup against applications table

    line 140
  17. Distinctive:

    If already applied → skip

    line 141
  18. Very specific:

    Gate: only run if referrals is in strategy.sources_active.

    line 143
  19. Very specific:

    If internal contact/alumni/ex-colleague found: stage referral request in messages and set card status to discovered (Strategy #1).

    line 145
  20. Very specific:

    If NO internal contact found: if strategy.cold_outreach = true, extract recruiter info and stage recruiter outreach DM in messages …

    line 146
  21. Very specific:

    If automation fails after 3 attempts → mark company as manual_apply_needed, notify user

    line 210
  22. Distinctive:

    Create account first, then search and apply

    line 211
  23. Distinctive:

    Look for "Apply" or "Postulate" or "Send CV" button

    line 235
  24. Distinctive:

    If it redirects to LinkedIn → apply via LinkedIn flow instead

    line 236
  25. Distinctive:

    If it's an email submission → draft email with CV attached, show to user (Gold Rule 6)

    line 237
  26. Very specific:

    If no apply button → mark as no_application_system in notes

    line 238
  27. Distinctive:

    Wait 3-5 seconds between actions (don't spam clicks)

    line 242
  28. Distinctive:

    Don't apply to more than 5 jobs per company per session

    line 243
  29. Distinctive:

    If a captcha or block appears → pause and notify user

    line 244
  30. Distinctive:

    If the session is interrupted, the next run picks up where it left off by querying:

    line 257
  31. Very specific:

    Browser: always use node .agents/skills/browser-automation/scripts/browser.js for open/close/goto.

    line 309
  32. Very specific:

    Resumable: Every action updates company_registrations.

    line 310
  33. Very specific:

    Must-haves are non-negotiable: Don't register or apply to companies that don't match the user's job_preferences (remote, location, AI …

    line 311
  34. Distinctive:

    Gold Rule 5: If manual login needed → open headed browser, notify user, wait

    line 313
  35. Distinctive:

    Gold Rule 6: If applying via email (not ATS form) → show draft to user before sending

    line 314
  36. Very specific:

    Dedup: Check applications table before applying.

    line 316

≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Targets — Active direct sourcing

Trigger

Keyword: targets

The user says targets (or variants: "register on companies", "apply to target companies", "company direct", "direct sourcing") and the full registration + application flow is triggered.

Purpose

The third sourcing pillar alongside radar (passive alerts) and apply (LinkedIn Easy Apply). This flow goes directly to the career sites of the target companies (loaded from users.data.target_companies in DB), registers the user, creates a standout profile, and applies to matching positions.

Pre-flight

  • Browser: always use node .agents/skills/browser-automation/scripts/browser.js for open/close/goto. See AGENTS.md "Browser session" and "Parallel execution" for details. Never call agent-browser open directly
  • Parallel execution: if running alongside other flows (e.g: apply or news), attach a session with node .agents/skills/browser-automation/scripts/browser.js attach --session targets-1 and pass --session targets-1 to all browser commands and scripts. Use detach when done (never close — it's ref-counted)
  • Load active preferences (see memory skill):
    node scripts/db.js "SELECT category, key, value, confidence, source FROM preferences WHERE user_id = <user_id> AND status = 'active' ORDER BY category, key"
  • Load strategy (see AGENTS.md "Strategy levels"):
    node scripts/db.js "SELECT data->'strategy' AS strategy FROM users WHERE id = <user_id>"
    Respect: targets_batch_size (max companies per session, 0 = don't run, "all" = no limit), match_threshold, relax_must_haves. If targets is not in sources_active, skip this flow entirely
  • Load profile, job preferences, CV and photo paths:
    node scripts/db.js "SELECT data->'profile' AS profile, data->'job_preferences' AS prefs, data->'cv_path' AS cv_path, data->'photo_path' AS photo_path, data->'style_profile' AS style_profile FROM users WHERE id = <user_id>"
  • Load company registrations to see current state:
    node scripts/db.js "SELECT id, company, region, sector, careers_url, ats_platform, registration_status, profile_completed, applied_jobs_count, notes FROM company_registrations WHERE user_id = <user_id> ORDER BY registration_status, region, company"
  • Load existing applications for dedup:
    node scripts/db.js "SELECT company, url FROM applications WHERE user_id = <user_id>"

Must-haves filter (from job_preferences)

Before applying to any job, verify against Must-haves from users.data.job_preferences. The filter is dynamic, not hardcoded. For each Must-weighted preference, discard if the job doesn't match. Common examples:

  • Work mode mismatch (if work_mode.weight = Must, role must match the user's preferred mode. If relax_must_haves resolves to include work_mode, accept partial matches)
  • Sector/specialization mismatch (if sector.weight = Must, role must be in the user's preferred sector)
  • Role level in deal_breakers (the user defines their own deal-breakers, never hardcoded. If the user listed "junior" as a deal-breaker, discard junior roles. If they didn't, don't)
  • In industries_avoid list (per industries_avoid.weight)
  • Salary below job_preferences.salary.value.min (if mentioned and salary.weight = Must)
  • Not in user's accepted locations (per location and timezones preferences)

Gold Rule 4: The user's career goal and what's sacrificable live in users.data.profile.career_goal and users.data.job_preferences. Read them from DB. Don't discard roles based on hardcoded assumptions about role type or seniority. Check relax_must_haves (resolved from users.data.job_preferences) to know which Must-haves are relaxed for the current strategy level.

Flow

Phase 1 — Registration & profile creation

For each company with registration_status = 'pending' (or profile_completed = false):

  1. Navigate to careers URL using node .agents/skills/browser-automation/scripts/browser.js goto <url> (or open if no session)
  2. Detect ATS if not already identified. Common signals:
    • URL contains greenhouse.io → Greenhouse
    • URL contains lever.co → Lever
    • URL contains ashbyhq.com → Ashby
    • URL contains workday → Workday
    • URL contains smartrecruiters.com → SmartRecruiters
    • URL contains teamtailor.com → Teamtailor
    • URL contains eightfold.ai → Eightfold
    • URL contains successfactors → SAP SuccessFactors
    • URL contains workable.com → Workable
    • URL contains phenom → Phenom
    • URL contains attrax → Attrax
    • URL contains gupy → Gupy
    • None of the above → Custom (manual inspection needed)
  3. Find the registration / sign up / create account page
  4. Login method priority:
    • Google login (preferred, reuses Gmail session from onboarding)
    • LinkedIn login (reuses LinkedIn session from onboarding)
    • Email + password (create account, save credentials to company_registrations.data as {email, password})
    • If no account creation possible → mark registration_status = 'manual_login_needed', notify user (Gold Rule 5)
  5. Complete profile to make it stand out:
    • Full name (from users.data.profile.full_name)
    • Title/headline: use profile.title + top skills (e.g: "<Title> | <Top Skills>")
    • Summary/bio: use profile.summary, adapted to the platform's character limit
    • Location: from users.data.personal_info (city, country) or form_answers.location
    • Upload CV: use profile.cv_path or personal_info.cv_pdf_path (from DB, never hardcoded)
    • Upload photo: use users.data.photo_path if the platform accepts it
    • Skills: add all from profile.skills
    • Experience: fill from profile.experience if the platform has structured fields
    • Languages: from profile.languages
    • Work preferences: from job_preferences.modalities, job_preferences.role_types
    • Salary expectation: from job_preferences.salary.value (only if field is required)
  6. Update DB after each company:
    node scripts/db.js "UPDATE company_registrations SET registration_status = 'registered', profile_completed = true, ats_platform = '<ats>', login_method = '<google|linkedin|email>', profile_url = '<url if available>', last_visit_at = NOW(), updated_at = NOW(), data = '<json with credentials if email login>'::jsonb WHERE id = <id>" --write
  7. Subscribe to job alerts if the ATS or career site supports it. This is critical for passive monitoring of new openings:
    • Greenhouse: look for "Subscribe to alerts" or "Email me new jobs" link on the job board. Enter email, select job categories or keywords (AI, Engineering, Remote)
    • Lever: look for "Subscribe" or "Alerts" button. Enter email, select departments or locations
    • Ashby: look for "Subscribe to alerts" link. Enter email, select teams or locations
    • Workable: look for "Subscribe" or "Job Alerts" link. Enter email, select job categories
    • SmartRecruiters: look for "Job Alerts" or "Subscribe" link. Enter email, select filters
    • Teamtailor: look for "Subscribe" or "Alerts" link. Enter email, select categories
    • Eightfold: AI matching may auto-suggest relevant jobs. Look for "Save search" or "Alerts" option
    • Workday: often has " Save Search" or "Job Alerts" after searching. Set up with filters
    • Custom ATS: look for any "Subscribe", "Alerts", "Notify me", or RSS feed icon. If none exists, skip this step and note it in company_registrations.notes
    • Keywords for alerts: derived from profile.skills, profile.title, and job_preferences (e.g: AI, the user's primary role, seniority level, key tech skills)
    • Frequency: daily if available, weekly otherwise
    • Email: use the user's email (from users.data.profile.email) so alerts route through the Gmail filter
    • Update DB with alert status:
      node scripts/db.js "UPDATE company_registrations SET data = jsonb_set(COALESCE(data, '{}'::jsonb), '{alerts_subscribed}', 'true'::jsonb), notes = COALESCE(notes, '') || ' | Alerts subscribed' WHERE id = <id>" --write
    • If alerts not available on the platform, note it:
      node scripts/db.js "UPDATE company_registrations SET notes = COALESCE(notes, '') || ' | No native alerts' WHERE id = <id>" --write

If a company has no matching roles or no remote options:

  • Mark registration_status = 'no_fit' with reason in notes
  • Do not register

If a company requires manual login (no Google/LinkedIn, no email signup):

  • Mark registration_status = 'manual_login_needed'
  • Open headed browser (Gold Rule 5), notify user, wait for confirmation

Phase 2 — Search & apply

For each company with registration_status = 'registered' and applied_jobs_count = 0 (or user requests more):

  1. Navigate to the company's job board
  2. Search with filters:
    • Keywords: derived from profile.title, profile.skills, and job_preferences (the user's primary role + key skills + seniority level)
    • Location: from job_preferences.location and job_preferences.timezones
    • Seniority: from job_preferences.seniority
  3. Filter by Must-haves (see above). For each matching job:
    • Check dedup against applications table
    • If already applied → skip
  4. Warm Sourcing & Referral Pre-Check (Strategy #1 & #4):
    • Gate: only run if referrals is in strategy.sources_active. If not, skip to step 5.
    • Run node scripts/linkedin-warm-sourcing.js --company "<Company>" --role "<Role>" --json
    • If internal contact/alumni/ex-colleague found: stage referral request in messages and set card status to discovered (Strategy #1).
    • If NO internal contact found: if strategy.cold_outreach = true, extract recruiter info and stage recruiter outreach DM in messages (Strategy #4). If cold_outreach = false, skip outreach. Either way, micro-align CV keywords to JD via scripts/generate-cv.js and proceed to ATS application.
  5. Apply following the ATS-specific flow (see ATS guide below)
  6. Register each application in DB:
    node scripts/db.js "INSERT INTO applications (user_id, platform, company, role, url, status, data) VALUES (<user_id>, '<company_lowercase>', '<company>', '<role>', '<url>', 'applied', '<json with match_reason, ats_type, location, salary_if_known>'::jsonb)" --write
  7. Update company registration:
    node scripts/db.js "UPDATE company_registrations SET applied_jobs_count = applied_jobs_count + <N>, last_applied_at = NOW(), updated_at = NOW() WHERE id = <id>" --write

Phase 3 — Report

Present to user:

## Targets report

### Registration summary
- Registered: X/40 companies
- Profile completed: X/40
- No fit (no remote/<country>/tech): X
- Manual login needed: X

### Applications summary
- Total applications via targets: X
- By company:
  | Company | Applied | Roles |
  |---|---|---|
  | Mercado Libre | 3 | Sr EM AI, AI Architect, Platform Eng |
  | Bitso | 2 | Sr EM, AI Engineer |
  ...

### Pending (need attention)
- [manual_login_needed] Santander Tecnología — requires manual login
- [no_fit] Nubank — all roles hybrid, no 100% remote

ATS-specific application guide

Greenhouse

  • URL pattern: job-boards.greenhouse.io/<company> or boards.greenhouse.io/<company>
  • "Apply" button → form with personal info, resume upload, custom questions
  • Resume: upload CV file directly
  • Questions: answer based on profile (years of experience, salary, location, work authorization)
  • Submit → confirmation page

Lever

  • URL pattern: jobs.lever.co/<company>
  • "Apply for this job" → form with name, email, phone, resume, links (GitHub, LinkedIn, portfolio)
  • Resume: upload CV file
  • Custom questions: answer from profile
  • Submit → email confirmation

Ashby

  • URL pattern: jobs.ashbyhq.com/<company>
  • "Apply" → multi-step form (personal info, experience, resume, questions)
  • Resume: upload CV file
  • May require cover letter — use a brief, tailored version from profile summary
  • Submit → confirmation

Workday

  • URL pattern: mywd.<company>.com or <company>.wd1.myworkdayjobs.com
  • Notoriously difficult to automate. Dynamic forms, anti-bot measures
  • If automation fails after 3 attempts → mark company as manual_apply_needed, notify user
  • Create account first, then search and apply

SmartRecruiters

  • URL pattern: careers.smartrecruiters.com/<company>
  • "Apply now" → form with personal info, resume, questions
  • Resume: upload CV file
  • May offer Google/LinkedIn prefill
  • Submit → confirmation

Teamtailor

  • URL pattern: <company>.teamtailor.com or <company>.na.teamtailor.com
  • "Apply" → form with personal info, CV, cover letter (optional)
  • Resume: upload CV file
  • Submit → confirmation

Eightfold

  • URL pattern: <company>.eightfold.ai/careers
  • AI-powered matching. May suggest roles based on profile
  • "Apply" → form, may offer LinkedIn import
  • Resume: upload CV file
  • Submit → confirmation

Custom / Unknown ATS

  • Navigate to the careers page
  • Look for "Apply" or "Postulate" or "Send CV" button
  • If it redirects to LinkedIn → apply via LinkedIn flow instead
  • If it's an email submission → draft email with CV attached, show to user (Gold Rule 6)
  • If no apply button → mark as no_application_system in notes

Anti-ban

  • Wait 3-5 seconds between actions (don't spam clicks)
  • Don't apply to more than 5 jobs per company per session
  • If a captcha or block appears → pause and notify user
  • Vary navigation order when browsing job lists
  • Take snapshots before interacting (LinkedIn-style tiptap editors are not the only ones with dynamic refs)

Resumability

The flow is fully resumable. The company_registrations table tracks state per company:

  • pending → not yet visited
  • registered → account created, profile completed
  • no_fit → no matching roles (with reason in notes)
  • manual_login_needed → requires user intervention
  • manual_apply_needed → Workday or similar that can't be automated

If the session is interrupted, the next run picks up where it left off by querying:

node scripts/db.js "SELECT * FROM company_registrations WHERE user_id = <user_id> AND registration_status = 'pending' ORDER BY region, company"

DB access

All DB access via scripts/db.js (see db skill). Read-only by default, --write for inserts/updates.

company_registrations table

ColumnTypePurpose
idSERIAL PK
user_idINTEGER FK → usersAlways 1
companyTEXTCompany name (unique per user)
regionTEXTlatam or argentina
sectorTEXTIndustry sector
careers_urlTEXTDirect URL to careers page
ats_platformTEXTDetected ATS type
registration_statusTEXTpending, registered, no_fit, manual_login_needed, manual_apply_needed
profile_completedBOOLEANWhether profile was fully filled
profile_urlTEXTURL to user's profile on the platform (if available)
login_methodTEXTgoogle, linkedin, email
applied_jobs_countINTEGERHow many jobs applied to via this flow
last_visit_atTIMESTAMPTZLast time the careers page was visited
last_applied_atTIMESTAMPTZLast time an application was submitted
notesTEXTFree-form notes (ATS details, role observations, no_fit reasons)
dataJSONBCredentials (if email login), extra metadata
created_atTIMESTAMPTZ
updated_atTIMESTAMPTZ

Typical queries:

# Pending companies
node scripts/db.js "SELECT id, company, region, careers_url, ats_platform, notes FROM company_registrations WHERE user_id = <user_id> AND registration_status = 'pending' ORDER BY region, company"

# Registered but no applications yet
node scripts/db.js "SELECT id, company, careers_url, ats_platform FROM company_registrations WHERE user_id = <user_id> AND registration_status = 'registered' AND applied_jobs_count = 0 ORDER BY company"

# Update after registration
node scripts/db.js "UPDATE company_registrations SET registration_status = 'registered', profile_completed = true, ats_platform = '<ats>', login_method = '<method>', profile_url = '<url>', last_visit_at = NOW(), updated_at = NOW() WHERE id = <id>" --write

# Mark as no_fit
node scripts/db.js "UPDATE company_registrations SET registration_status = 'no_fit', notes = '<reason>', last_visit_at = NOW(), updated_at = NOW() WHERE id = <id>" --write

# Increment applied count
node scripts/db.js "UPDATE company_registrations SET applied_jobs_count = applied_jobs_count + <N>, last_applied_at = NOW(), updated_at = NOW() WHERE id = <id>" --write

Rules

  • Browser: always use node .agents/skills/browser-automation/scripts/browser.js for open/close/goto. Never agent-browser open directly
  • Resumable. Every action updates company_registrations. If interrupted, next run continues from where it left off
  • Must-haves are non-negotiable. Don't register or apply to companies that don't match the user's job_preferences (remote, location, AI focus, salary, industries_avoid)
  • Gold Rule 4. Manager is preferred but sacrificable for interesting IC roles with AI focus and good compensation
  • Gold Rule 5. If manual login needed → open headed browser, notify user, wait
  • Gold Rule 6. If applying via email (not ATS form) → show draft to user before sending
  • Anti-ban. 3-5 second delays, max 5 applications per company per session
  • Dedup. Check applications table before applying. Don't apply to the same job twice
  • Persist everything. Registration status, profile completion, applications, credentials (in data JSONB)
  • CV and photo paths come from users.data.cv_path and users.data.photo_path. Never hardcode paths
  • Single user (repo owner)

Dependencies

  • Depends on onboarding (DB, browser profile, Gmail + LinkedIn sessions)
  • Depends on profile (Must-haves to filter, profile data to fill forms)
  • Consume by daily (can be added as a third pillar alongside news + apply)

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.