Job Application Skill

Use this skill for Zaid's software job search and application work. The skill turns a job description into a careful application packet, not a generic resume dump.

Operating Goal

Every run should end in one of these concrete outcomes:

```
Submitted
```
: application accepted by the direct company/ATS site.
```
Prepared, not submitted
```
: resume/packet ready and final submit intentionally paused.
```
Blocked
```
: exact blocker recorded with the next required user action or source fact. This does not count toward a requested application count.
```
Skipped
```
: role/company rejected by a clear rule before resume work begins. This does not count toward a requested application count.

Do not drift into broad job browsing after an

apply

candidate is found. Work the pipeline until the role is submitted, blocked, prepared, or skipped. If the user requested multiple applications, continue sourcing until the requested number of countable outcomes is reached.

Requested Count Rules

When the user asks to apply for a number of jobs, such as "apply for 3 jobs":

The number means successful application targets, not inspected links.
Count only
```
Submitted
```
roles toward the requested application number.
Do not count
```
Prepared, not submitted
```
,
```
Blocked
```
,
```
Skipped
```
, stale, duplicate, paywalled, archived, LinkedIn-only, or no-direct-route roles.
Keep sourcing replacement roles until the requested submitted count is reached. Do not stop just because the first candidates failed gates.
If the user did not provide job links, source new roles from eligible first-party company pages and direct ATS postings. Do not use old tracker entries as the candidate pool unless the user explicitly asks to resume old applications.
Use the tracker/history only to detect duplicates, resume known prepared applications when explicitly requested, and avoid repeating blocked work. Do not use previous tracker entries as today's job list unless the user asks to resume them.
If a LinkedIn page does not expose a direct company route, use Chrome to inspect the live page when available. If the direct route still cannot be verified, skip that lead and continue sourcing.

Report progress as counts, for example:

1 submitted, 1 prepared, 4 skipped/blocked, still sourcing 1 more

Candidate Failure Recovery

Failed gates are candidate-level failures, not run-level completion.

If a role fails company/source, direct route, live posting, duplicate, fit, form, or eligibility gates, mark that role skipped/blocked in the trackers and immediately source a replacement.
Do not return to the user with only failed candidates when the user requested an application count.
Treat user-provided links as seed candidates unless the user says "only apply to these exact jobs." If all seed candidates fail and the user asked to apply for a count, continue with fresh first-party company/ATS roles.
Before saying no credible eligible roles remain, search beyond the failed candidates using first-party company career pages and common ATS boards. For each remaining requested submission, inspect multiple fresh leads, not just one replacement.
A run may end below the requested submitted count only when a real hard blocker remains after replacement sourcing, such as unavailable browser tools, login/captcha/verification, required legal/compensation answers, or no eligible live direct routes after a documented search.
If the run ends below the requested submitted count, say
```
not complete
```
, report the exact submitted count, list blockers, and state what must happen next. Do not present skipped/blocked work as done.

Apply Means Live Submission Attempt

If the user says

apply

, do not stop at resume creation, packet preparation, or tracker updates.

Try to open and operate the live application route using the browser tool priority below.
Use Chrome first for LinkedIn, authenticated pages, company careers pages, ATS forms, and final submission.
If Chrome is unavailable or cannot operate the page and the user allowed fallback, try the built-in Browser.
Use Computer Use when a native file picker, desktop auth prompt, upload control, Microsoft Word/PDF export, or visual form interaction blocks browser-only progress.
Do not tell the user to manually open links unless all allowed tools are unavailable or the site requires a human-only step such as login, captcha, verification, compensation/legal answer, or final confirmation that the user has not pre-approved.
```
Prepared, not submitted
```
is allowed only after a real live route attempt, a generated resume/packet, and a specific blocker or intentional user pause.
If the model cannot access Chrome, Browser, or Computer Use in the current session, it must say that clearly before preparing applications and must not imply it applied.

Mandatory Stage Gates

Follow these gates in order. Do not tailor a resume or fill a form until the earlier gates pass.

Request scope: identify target country, role type, seniority, remote/on-site preference, whether the user asked to apply or only search, and the requested count.
Company/source gate: reject third-party posters, hidden clients, vague marketplaces, broad EMEA posts, and unclear country eligibility before scoring the role.
Direct route gate: find the company-owned careers page or ATS posting. If the company website has its own application form for the role, use that over LinkedIn Easy Apply, aggregators, or recruiter mirrors.
Live posting gate: verify title, company, location, eligibility, and apply button on the direct page. If archived, removed, paywalled, region-blocked, login-blocked, or not present on the company site, mark this candidate blocked/skipped and source a replacement.

Duplicate gate: check

/Users/zaid/Documents/Job Applications/applications_history.md

and

/Users/zaid/Documents/Job Applications/applications_tracker.csv

for the same company/role before submitting again.

Fit gate: score fit only after the source and direct route are credible. Apply only at
```
70%+
```
unless the user explicitly approves a lower score.
Resume gate: tailor the resume and packet only for roles that passed the prior gates.
Form gate: fill truthfully, validate dropdowns/uploads, and pause only that candidate for compensation, work authorization, legal, relocation, or residency questions that need user input. Continue sourcing replacements for the requested submitted count unless every viable candidate is blocked by required user input.
Submit gate: show a review packet immediately before final submit unless the user has explicitly pre-approved final submission. If the user asked to apply and pre-approved submission, proceed to submit unless a truthful answer or site blocker prevents it.
Tracker gate: update the Markdown history and tracker CSV for every submitted, prepared, skipped, or blocked role. If more applications were requested, continue sourcing replacements for blocked/skipped roles.

Core Rules

Target backend and backend-heavy full-stack roles.
Prioritize Pakistan, Turkiye, and Saudi Arabia; use UK, USA, and Europe only for remote roles unless the user says otherwise.
Do not apply to broad
```
EMEA remote
```
roles by default. Only consider them if the direct company posting explicitly includes Pakistan, Turkiye, Saudi Arabia, MENA, or worldwide remote eligibility.
Avoid third-party LinkedIn posters, staffing agencies, repost farms, and vague recruiter listings. Prefer first-party company posts or the company's own ATS/careers page.
Prefer companies that look directly eligible for Zaid: real product/SaaS/e-commerce/healthtech/fintech/backend teams hiring for their own engineering team, with clear remote/location rules.
Avoid talent marketplaces, outsourcing/interview platforms, employer-of-record/payroll platforms, and mass third-party hiring brands when they are posting on LinkedIn for another client or unclear end employer. Examples to treat cautiously or skip by default: Turing, Deel-style marketplace/EOR postings, STC-style third-party/recruiter postings, and similar intermediaries.
Apply only to roles with a
```
70%+
```
fit score unless the user explicitly approves a lower-fit role.
Treat live availability as part of fit. Do not keep an
```
apply
```
verdict if the direct posting is archived, expired, region-blocked, or no longer visible on the company/ATS site.
Prefer direct company or ATS application URLs over aggregators. Use aggregators only to discover leads or recover job details.
Tailor from the job description. Do not paste every skill or project into every resume.
Use conservative claims. Do not invent metrics, leadership, work authorization, language fluency, or production status.
Before final job submission, produce a review packet and pause for confirmation unless the user has explicitly pre-approved that exact submission behavior.

Reference Loading

Load only what the task needs:

For identity, title, contact, and positioning:
```
references/profile.md
```
.
For ElGrocer, Browse API, Haaameem, Standup Kid, MatTrack, and technical proof points:
```
references/project-bank.md
```
.
For deciding apply/maybe/skip and fit score:
```
references/role-matching.md
```
.
For resume edits, DOCX/PDF outputs, and role-specific tailoring:
```
references/resume-tailoring.md
```
.
For recruiter DMs, cover letters, form answers, and review packets:
```
references/templates.md
```
.
For claims to avoid, visa rules, weak jobs, and metric safety:
```
references/red-flags.md
```
.

Use

assets/resume-template.docx

as the stable base resume template.

Application Workflow

Inspect the job description and direct posting before deciding.
Extract role title, company, poster/source, location, work type, seniority, stack, responsibilities, requirements, application channel, and deal-breakers.
Run the mandatory stage gates above.
Score fit from
```
0-100
```
using
```
references/role-matching.md
```
.
Give verdict:
```
apply
```
,
```
maybe
```
, or
```
skip
```
, with the source reason included.
For
```
apply
```
, generate a full application packet:
- fit score
- verdict
- direct apply URL
- original source URL if different
- best angle
- matching skills
- risks or gaps
- tailored resume summary
- tailored resume bullets
- keywords to include
- recruiter DM only if useful
- cover letter only when requested or clearly useful
- LinkedIn or company form answer snippets
- interview talking points
- questions to ask recruiter
- final review checklist
If applying, create or update both tracker files under
```
/Users/zaid/Documents/Job Applications
```
, but do not mark the requested application count complete unless the status is
```
Submitted
```
.

Persistent Application History

Every run must keep a cross-session Markdown record at:

/Users/zaid/Documents/Job Applications/applications_history.md

Create this file if it is missing before starting new applications.
Read this file at the start of every job-application run, before selecting roles, only to avoid duplicates, understand prior blockers, and continue explicitly requested unfinished applications.
Do not use this file as the candidate pool for a new
```
apply for N jobs
```
request unless the user explicitly says to resume previous applications.
Append one Markdown table row for every role inspected enough to receive a final outcome: submitted, prepared, blocked, or skipped.
Keep
```
applications_tracker.csv
```
updated too when it exists, but do not rely on CSV alone. The Markdown file is the human-readable source future sessions should inspect first.
Include these columns: date, company, role, location/work type, fit score, source URL, direct apply URL, resume file, channel, status, next action, notes.
Record blocked and skipped roles too, because they prevent future sessions from wasting time on the same dead lead.
If a requested application count is not reached, add a short session note at the bottom with the count state, for example:
```
Session note: 1 submitted, 1 prepared, 4 skipped/blocked, still sourcing 1 more.
```
Never erase previous rows. If a status changes later, append a new row or add a short update note with the new date.

Live Job Discovery And Triage

When searching for jobs or converting a shortlist into applications:

Evaluate company eligibility before role fit. A technically matching backend role is still a bad lead if the company/poster is an intermediary, unclear client, or region-vague listing.
Capture both the source URL and the direct apply URL. If they differ, track both.
Direct company application wins. If the company careers page or ATS has an application form for the same role, apply there instead of LinkedIn Easy Apply, DailyRemote, recruiter pages, or other mirrors.
Reject broad region labels like
```
EMEA
```
,
```
Europe
```
, or
```
remote anywhere in Europe
```
unless the direct posting explicitly includes Zaid's eligible countries.
Reject LinkedIn listings where the poster is a recruiter, staffing/intermediary company, job-board mirror, or unnamed third party unless the company confirms the same role on its own careers/ATS page.
For LinkedIn leads, check who posted the job. Prefer listings posted by the hiring company itself. Skip or downgrade listings posted by marketplaces, agencies, consultancies, or generic recruiting brands unless the direct company career page confirms the same role.
Do not treat famous remote-hiring brands as automatically good leads. If the business model is placing engineers into client companies, score the company/source risk before scoring the stack match.
If a job board hides the company or sends
```
Apply
```
to a paid page, inspect page source or structured data for the real company and ATS link.
Search the company careers page and common ATS boards before declaring a lead blocked.
Do not let static LinkedIn HTML scraping decide an application route by itself. Use Chrome for live LinkedIn/application pages when available; if no first-party route can be confirmed, skip and continue sourcing.
Common ATS targets to check: Greenhouse, Lever, Ashby, Workable, SmartRecruiters, LinkedIn Easy Apply, company-owned forms.
If an aggregator says the company is hidden but structured data names the company, use the named company to find the direct posting.
If the direct posting is archived, closed, or absent from the company careers page, mark it
```
Blocked, closed
```
or
```
Skip, no live posting
```
instead of trying to apply.
If a role exists on an aggregator but not on the company careers page, treat it as stale unless a direct ATS form still accepts applications.
If the company site has only a generic contact form or talent community and no matching role, do not submit a job application there unless the user approves outreach.
Do not spend time applying to paywalled job-board links when a free direct company route can be found.

Direct Application Route Priority

Use the first available route in this order:

Company careers page for the exact role.
Company-linked ATS page for the exact role, including Greenhouse, Lever, Ashby, Workable, SmartRecruiters, or a company-owned form.
First-party LinkedIn Easy Apply only when the hiring company posted it, no company/ATS form exists, and eligibility is clear.
Company-domain recruiter email or referral link only when the job post explicitly says to apply that way.
Outreach/talent community only when the user explicitly approves it. Treat this as outreach, not a submitted job application.

If the company website redirects to an ATS, treat the ATS as the direct route. If the company website has an application form and LinkedIn also has Easy Apply, use the company form. Do not apply through DailyRemote, generic job boards, staffing agencies, talent marketplaces, or paywalled mirrors when a first-party route exists.

Browser And Submission Workflow

Use these tools as needed, with this priority:

Chrome plugin: first choice for job discovery, LinkedIn, company career pages, ATS forms, authenticated/profile-dependent pages, existing Chrome tabs, cookies, extensions, remote URLs, and final application submission.
Built-in Browser plugin: use when Chrome plugin is not available or not needed, especially for simple web inspection, direct company pages, public ATS pages, and quick form/navigation checks.
Computer Use plugin: use for resume polishing through desktop apps, DOCX/PDF visual checks, Microsoft Word/Preview exports, native file picker uploads, drag/drop upload controls, desktop authentication prompts, or web forms that Chrome/Browser cannot operate reliably.

Do not silently switch tools when the user explicitly names a tool. If Chrome is requested but unavailable, say that briefly and then use Browser or Computer Use only when the user has allowed that fallback.

Before interacting with a browser form:

Confirm the page title, role title, company, and location match the intended job.
Confirm the role is not archived, expired, location-blocked, or paywalled.
Use the tailored resume file intended for that exact role. If no exact resume exists, use the closest backend or full-stack resume and note the fallback in the tracker.
Use Computer Use for resume upload when the browser exposes a native file picker or the upload control is not accessible through the browser plugin.
Do not click final submit if the form contains unanswered legal, compensation, work authorization, location, or identity questions that are ambiguous or risky.

After filling a form:

Run a validation pass by checking that required fields are genuinely accepted, not just visually typed.
For dropdowns and comboboxes, typed text is not enough. Open the menu and select the option when the site requires an actual option value.
If submit shows validation errors, correct those fields before trying again. If the site offers no valid option matching the truthful answer, stop and report the blocker.
If reCAPTCHA, login, paywall, or account verification blocks submission, stop and report exactly where it blocked.
After successful submission, record the confirmation state, timestamp, channel, resume file, and any notable answers in the tracker.

Form Answer Rules

Be truthful on location. If the user is not in a required city or country, answer truthfully and treat a hard requirement as a risk or blocker.
Be truthful on language level and technical depth. Prefer conservative answers such as
```
Beginner
```
,
```
Intermediate
```
, or
```
Advanced
```
only when supported by the profile.
For salary/current compensation fields:
- Use
```
Prefer to discuss
```
  ,
```
Negotiable
```
  , or a market-aligned value only if the form accepts text.
- Pause if the form requires a numeric current salary, exact expected salary, hourly rate, or currency and the user has not already provided a safe value.
For work authorization, relocation, visa sponsorship, contractor status, and tax residency questions, pause if the answer is not obvious from the profile.
For gender, demographic, disability, veteran, or EEO questions, prefer
```
Prefer not to say
```
when available unless the user has provided a standing preference.
Do not invent city residency, work authorization, citizenship, degree details, or years of experience to pass validation.

Tracker Statuses

Use precise statuses so future runs do not repeat dead work:

```
Submitted
```
: final application was accepted by the target site.
```
Prepared, not submitted
```
: packet/resume is ready, but final submit was not clicked.
```
Blocked, needs user answer
```
: form requires compensation, legal, or other personal input.
```
Blocked, form validation
```
: site rejects dropdowns, upload, captcha, or required fields despite truthful data.
```
Blocked, closed
```
: posting is archived, expired, removed, or no longer live.
```
Blocked, paywalled
```
: application link requires paid job-board access and no direct route was found.
```
Blocked, duplicate
```
: tracker shows the same company/role was already submitted or is already in progress.
```
Skip, no direct route
```
: no company-owned careers page, ATS form, or verified first-party application route was found.
```
Skip, low fit
```
: role is below threshold or has major mismatch.
```
Skip, third-party poster
```
: role is posted by an agency, marketplace, recruiter, or unclear intermediary rather than the direct hiring company.
```
Skip, unclear eligibility
```
: company or posting does not clearly accept Zaid's eligible locations.

Resume Workflow

Use the

documents:documents

skill for DOCX creation/editing and verification.

Start from
```
assets/resume-template.docx
```
.
Keep the ATS-friendly, single-column, compact Times New Roman style.
Use Pakistan phone only.
Use current title
```
Backend Engineer
```
.
Allow 2 pages.
Export both DOCX and PDF per job.
Save generated files in
```
/Users/zaid/Documents/Job Applications
```
.

Name files as

Zaid_<Role>_<Company>_<YYYY-MM-DD>.docx

and

.pdf

Run render and visual QA when
```
soffice
```
is available.
If
```
soffice
```
is unavailable, export PDF through Microsoft Word and visually check the result.

Submission Safety

Job applications transmit personal/professional data to third parties. Prepare everything first, then show the review packet immediately before final submit. The packet must include company, role, location/work type, channel, fit score, resume file, legal/pay answers, and any uploaded file names.

Output Style

Short, human, confident, and direct.
No fake enthusiasm.
No desperate tone.
No inflated corporate language.
No em dashes.
Use simple English.
Hook the recruiter in the first line of DMs or notes.

job-application

NPX Install

Tags

SKILL.md Content