diff --git a/docs/README.skills.md b/docs/README.skills.md index fbae02823..ef9d32736 100644 --- a/docs/README.skills.md +++ b/docs/README.skills.md @@ -227,6 +227,7 @@ See [CONTRIBUTING.md](../CONTRIBUTING.md#adding-skills) for guidelines on how to | [java-springboot](../skills/java-springboot/SKILL.md)
`gh skills install github/awesome-copilot java-springboot` | Get best practices for developing applications with Spring Boot. | None | | [javascript-typescript-jest](../skills/javascript-typescript-jest/SKILL.md)
`gh skills install github/awesome-copilot javascript-typescript-jest` | Best practices for writing JavaScript/TypeScript tests using Jest, including mocking strategies, test structure, and common patterns. | None | | [javax-to-jakarta-migration](../skills/javax-to-jakarta-migration/SKILL.md)
`gh skills install github/awesome-copilot javax-to-jakarta-migration` | Migrate Java code from javax.* to jakarta.* namespace. Use when upgrading to Tomcat 11, Jakarta EE 10, or when javax imports are detected in the codebase. | None | +| [jobstead](../skills/jobstead/SKILL.md)
`gh skills install github/awesome-copilot jobstead` | Helps a job-seeker decide whether a role is actually worth their time, then tells their story for it — beautifully. Grounded in persistent, personalized knowledge of the person (profile, application tracker, lessons learned across the search) and the specific posting, not generic one-shot advice. Use this whenever the user asks things like "is this role worth applying to", "should I apply to this", "is this job a fit for me", "am I wasting my time on this posting", "review this job listing", "pick up my job search", "is this posting a scam", "tell my story for this role", "build/tailor my resume for this job", or wants to resume a multi-session job hunt and check in on an application tracker. Also handles ATS optimization and resume formatting, but only as a supporting step after the fit-check and story are established — not for pure one-shot formatting requests unrelated to a specific role or ongoing search. | `references/lessons.md`
`references/log.md`
`references/profile.md`
`references/tracker.md` | | [kotlin-mcp-server-generator](../skills/kotlin-mcp-server-generator/SKILL.md)
`gh skills install github/awesome-copilot kotlin-mcp-server-generator` | Generate a complete Kotlin MCP server project with proper structure, dependencies, and implementation using the official io.modelcontextprotocol:kotlin-sdk library. | None | | [kotlin-springboot](../skills/kotlin-springboot/SKILL.md)
`gh skills install github/awesome-copilot kotlin-springboot` | Get best practices for developing applications with Spring Boot and Kotlin. | None | | [legacy-circuit-mockups](../skills/legacy-circuit-mockups/SKILL.md)
`gh skills install github/awesome-copilot legacy-circuit-mockups` | Generate breadboard circuit mockups and visual diagrams using HTML5 Canvas drawing techniques. Use when asked to create circuit layouts, visualize electronic component placements, draw breadboard diagrams, mockup 6502 builds, generate retro computer schematics, or design vintage electronics projects. Supports 555 timers, W65C02S microprocessors, 28C256 EEPROMs, W65C22 VIA chips, 7400-series logic gates, LEDs, resistors, capacitors, switches, buttons, crystals, and wires. | `references/28256-eeprom.md`
`references/555.md`
`references/6502.md`
`references/6522.md`
`references/6C62256.md`
`references/7400-series.md`
`references/assembly-compiler.md`
`references/assembly-language.md`
`references/basic-electronic-components.md`
`references/breadboard.md`
`references/common-breadboard-components.md`
`references/connecting-electronic-components.md`
`references/emulator-28256-eeprom.md`
`references/emulator-6502.md`
`references/emulator-6522.md`
`references/emulator-6C62256.md`
`references/emulator-lcd.md`
`references/lcd.md`
`references/minipro.md`
`references/t48eeprom-programmer.md` | diff --git a/skills/jobstead/SKILL.md b/skills/jobstead/SKILL.md new file mode 100644 index 000000000..a6cee4af8 --- /dev/null +++ b/skills/jobstead/SKILL.md @@ -0,0 +1,196 @@ +--- +name: jobstead +description: Helps a job-seeker decide whether a role is actually worth their time, then tells their story for it — beautifully. Grounded in persistent, personalized knowledge of the person (profile, application tracker, lessons learned across the search) and the specific posting, not generic one-shot advice. Use this whenever the user asks things like "is this role worth applying to", "should I apply to this", "is this job a fit for me", "am I wasting my time on this posting", "review this job listing", "pick up my job search", "is this posting a scam", "tell my story for this role", "build/tailor my resume for this job", or wants to resume a multi-session job hunt and check in on an application tracker. Also handles ATS optimization and resume formatting, but only as a supporting step after the fit-check and story are established — not for pure one-shot formatting requests unrelated to a specific role or ongoing search. +--- + +# Jobstead + +Jobstead helps a job-seeker spend their search energy where it can pay off: the right roles, told +with their real story, grounded in what's actually true about them and the posting — not volume, +not generic resume polish. This file carries the methodology. State (who the applicant is, what +they've applied to, what's been learned) lives in the reference files below and persists across +sessions. Skill port of the plain-chat [Jobstead playbook](https://raw.githubusercontent.com/adibas03/jobstead/refs/tags/v3.5/Jobstead.md). + +## Session start — load state + +Before doing anything else, check for existing state: + +1. Look in `references/` next to this file for `profile.md`, `tracker.md`, `lessons.md`, `log.md`. +2. The applicant may have been using Jobstead from a different surface last time, so also check + whatever else this environment makes available for persistent state. The exact options vary by + tool and aren't listed exhaustively here — examples include a project's `MEMORY.md`, an MCP + memory store, or the model's own native memory. +3. **If found:** load it, and tell the applicant what you found — surface the profile name (if + any), the last sync date, and how many tracker entries exist. This lets a stale or wrong file + get caught immediately rather than silently driving the session. +4. **If not found:** ask the applicant whether they have a Jobstead state file to resume from + (they may have one saved from a plain-chat session or a different tool), and stop there for that + turn rather than also asking about a resume in the same breath — one question at a time reads + better for someone already in the middle of a stressful job search. If yes, take the file and + use it to populate `references/`. If no, *then* ask separately whether they have a resume to + share. Parsing a resume answers most of Profile in one pass — identity, career summary, stack, + education — far faster than asking field-by-field, and it's what a real applicant would expect + to be asked for next. Fill in whatever the resume covers, then ask directly only for what it + couldn't tell you (typically work authorization for roles outside their home country, and target + roles/constraints — a resume rarely states what someone wants next). If they have no resume + either, fall back to asking directly. Somewhere in this sequence, briefly explain the + persistence loop once: knowledge (lessons) accrues automatically as you work together; personal + info (profile, tracker) is only written when they confirm; at session end you'll offer them an + updated copy to save. Skip this explanation for a returning applicant whose profile is already + populated. + +Load `references/profile.md` at launch alongside this file — it's small and you'll need it for the +fit-check. Leave `references/tracker.md`, `references/lessons.md`, and `references/log.md` unread +until a task actually calls for them (tracking work, reasoning from accumulated experience, or +session-audit respectively) — they can grow large and reloading them for every turn wastes context +for no benefit. + +## 1. Upfront fit check (run BEFORE any tailoring) + +This check only works against a populated Profile. If the applicant shares a posting to review and +`references/profile.md` is still blank or missing the fields this check needs (work authorization, +languages, credentials, target roles/constraints), gather those first — a fit-check against an +empty profile isn't a fit-check, it's a guess dressed up as one. If bootstrapping hasn't happened +yet this session, start by asking for a resume (see above) rather than asking these fields one by +one; only ask directly for whatever the resume didn't cover. + +This is Jobstead's actual differentiator — most tools skip straight to polishing a resume for +whatever role was pasted in. Don't. Evaluate against `references/profile.md` in this order, and +stop at the first **hard** filter that fails with no real workaround: + +1. **Work authorization** *(hard)* — Does the role need work rights the applicant lacks, and is + the company unwilling or unable to sponsor? Pull the applicant's authorization from their + Profile first; only ask directly if it isn't there. Then compare against the role's + requirement. Signals worth reading closely: "Remote [single country]" almost always means + "must already be authorized there" unless sponsorship is explicitly offered; defence, + intelligence, and most government roles are typically citizen-only; a sponsorship question + asked early in the application form is usually a real filter, not a formality. +2. **Language** *(hard)* — especially for European public-sector or local-market roles. C1+ in a + language the applicant doesn't have is a wall, not a stretch goal. +3. **Hard credentials** *(hard)* — a required master's/PhD, a government security clearance, a + professional license. Public research institutes and government bodies tend to enforce these + strictly, not just list them as nice-to-have. +4. **Title fit** *(soft)* — has the applicant actually held this title, or only done equivalent + work under a different one? Title gaps are a common screen-stage rejection reason even when the + underlying work matches. +5. **Stack/skill match** *(soft)* — production experience in the core technologies, or only + adjacent ones? +6. **Seniority band** *(soft)* — under-credentialed, well-matched, or significantly over-leveled? + Both ends hurt at the screen. +7. **Domain alignment** *(soft)* — does the industry or the role's evident values conflict with + anything the applicant has flagged as a red line in their Profile? + +**Decision rule:** any failed hard filter with no workaround → recommend skipping the role, and say +so plainly rather than tailoring materials anyway. Only soft filters in question → lay out the +honest picture and let the applicant decide; don't decide for them. + +## 2. Scam markers — check before investing any more time + +Two or more of these on a posting is high-risk; verify against the country's official sponsor +register (or equivalent) before going further: + +- Salary below the country's visa-sponsorship minimum, yet sponsorship is advertised as a benefit +- Keyword-stuffed requirements (30+ technologies, or mutually exclusive stacks listed together) +- Generic AI-sounding description with no concrete product, team, mission, or named client +- Shell-company suffix with no real registry footprint (e.g. no Companies House entry) +- No real company website, or an obvious template site with stock photography +- Two listed addresses that don't match each other +- No sponsor licence number despite offering sponsorship +- Requests for passport, ID, bank details, or a "processing fee" before any formal offer +- The exact listing is aggregated across many boards with no matching careers page on the + company's own site + +## 3. Story-resume — the tailoring strategy + +Once a role clears the fit-check, build a resume and cover letter grounded in the applicant's +actual story and the specific posting — not a generic reformat and not pure ATS-formatting. This +is the other half of Jobstead's differentiator: a coherent narrative of why *this applicant* fits +*this role*, drawn from the Profile and the fit-check just run. + +1. Read the JD closely: the literal title, the 5–10 most-repeated keywords, which requirements are + "must have" vs. "nice to have," and the company's tone/voice. +2. Reposition the headline to match this specific role family — don't reuse one headline across + every application. +3. Reorder skills to put the JD's primary keywords first. +4. Rewrite flagship-role bullets to lead with the JD's own language — same achievements, different + framing, never invented ones. +5. Trim sections that are irrelevant to this role (e.g. blockchain work for a non-Web3 posting). +6. Address any known gaps honestly in the cover letter — see below. +7. Match the company's voice: casual postings get a casual letter, formal postings a formal one. + +**Cover letter standards:** +- One page max. +- Open with the strongest hook, usually a specific JD line that genuinely resonates with the + applicant's real background. +- Surface known concerns up front — location, sponsorship, a title or stack gap. Acknowledging a + gap with a concrete ramp plan reads as confidence; hiding it and having it surface in a screen + call reads as risk. +- Use specifics over generics: name real products, named recruiters if known, specific stack + components pulled from the JD. +- End with a concrete next step (a technical test, a paid trial, a specific problem to discuss). + +**Honest framing, always:** +- Never fake credentials, degrees, certifications, or citizenship. +- Don't overclaim depth — label sparse experience "familiar with," or leave it out, rather than + listing it as a strength. +- Don't hide structural blockers (location, work auth, a title gap) — they surface in the screen + call regardless; better to surface them on the applicant's own terms in the cover letter. +- Play to strengths rather than stretching to hit every keyword in the posting. + +## 4. ATS optimization — a supporting step, not the goal + +Apply this *after* the story is grounded, to help that story actually reach a human screener. It's +in service of the narrative above, not a replacement for it: + +- Mirror the JD's exact job title verbatim somewhere in the headline, subtitle, or summary. +- Include both spellings where stack-name variants exist ("Next.js" / "NextJS", "Node.js" / + "NodeJS") — ATS systems often treat these as separate tokens. +- Use the JD's literal keyword phrasing even when a synonym is equivalent ("AWS services" and + "AWS (ECS, Lambda)"; "DevOps" and "CI/CD"). +- Include 5+ quantified achievements across the resume (numbers, %, $, user or transaction counts). +- Use standard section headers only — Summary, Experience, Skills, Education — never creative ones. +- Avoid tables, columns, text boxes, headers/footers, or graphics; keep a single-column flow. +- Use standard fonts (Calibri, Arial, Helvetica, Georgia) and Month-Year dates. +- Cap length at 2 pages for senior roles, 1 page for early-career. +- Put contact info in the body text, not in a header/footer. +- Prefer .docx where the application form accepts it — it tends to parse more reliably than PDF; + use PDF as a fallback. +- A hard degree-field mismatch for a role that requires it (e.g. non-CS for a strict CS + requirement) is often an unfixable filter — accept it as a known miss rather than fake it. + +**Submission speed (the 48-hour rule):** for a role that clears the fit-check as a strong match, +get tailored materials submitted within 48 hours of finding it. Strong-fit roles close fast, and +the ATS-optimization defaults above should not delay submission past this window — ship the +strongest version that fits the window, not the strongest version achievable with unlimited time. + +## 5. Where to look — source quality + +- Aggregators filtered specifically by "visa sponsorship" (e.g. generic job boards' sponsorship + filters) attract scams and body-shop postings — treat with caution. +- A real sponsor usually just lists the role; they rarely advertise sponsorship as a headline + "benefit." +- Higher-quality sources tend to be: direct company careers pages (especially at verified + sponsors), Y Combinator's Work at a Startup, Wellfound, Otta, RemoteOK filtered to "worldwide," + Remotive, We Work Remotely, and official government sponsor-licence registers where published. +- General aggregator boards for a region are mixed-quality but do contain real opportunities — + run the fit-check rigorously rather than filtering the source out entirely. +- Government and public-sector portals are mostly citizen/PR-first at the specialist level; + check only for the specific bodies known to hire foreigners, and verify current policy rather + than relying on a remembered list, since these change. + +## During the session + +Take one role at a time. Always run the fit-check (§1) before tailoring anything (§3). When an +application is submitted, log it in `references/tracker.md`. When something genuinely new and +useful is learned — a pattern about a market, a source, a scam signal — capture it as a dated, +identity-free entry in `references/lessons.md`; it's meant to accumulate across sessions and +should never contain anything that identifies the applicant. + +## Session end — write state back + +If meaningful state has accumulated this session (new tracker entries, profile changes, session +activity), offer the applicant an updated copy before ending: confirm any profile changes and +tracker updates explicitly (never write personal info silently), append a dated entry to +`references/log.md` summarizing what happened, and let them know the reference files now hold the +current state for next time. + diff --git a/skills/jobstead/references/lessons.md b/skills/jobstead/references/lessons.md new file mode 100644 index 000000000..7333c4a0c --- /dev/null +++ b/skills/jobstead/references/lessons.md @@ -0,0 +1,33 @@ +# Lessons + +Persistent, identity-free observations that accumulate across sessions. Anyone can add one when +something genuinely new and useful is learned; there's no attribution needed and no need to ask +before appending — this is meant to grow quietly as a byproduct of doing the work. The one rule +that matters: strip anything that identifies the applicant, a specific employer, or an individual +before writing it here. Capture the pattern, not the case. + +Format: `[YYYY-MM-DD] Lesson statement.` + +Seeded from the accumulated Jobstead playbook (patterns only, dates preserved for context; verify +anything with a specific figure or named policy before relying on it, since these shift over time): + +- `[2026-05-26]` "Remote [single country]" in a job ad nearly always means "must be authorized to + work in that country," unless sponsorship is explicitly mentioned. Treat as a hard filter. +- `[2026-05-26]` Visa-sponsoring countries often set salary floors that scale by role, with + going-rate thresholds for specialist roles sitting well above the general floor. A sponsorship + offer paired with a salary far below the general floor is structurally implausible — verify + current figures on the relevant government site rather than trusting the posting. +- `[2026-05-26]` Public-sector roles (statutory boards, ministries) tend to be citizen/PR-first; + defence, security, and intelligence bodies are typically citizen-only. Some specialist tech + agencies are exceptions but the bar is high — treat "public-sector = local-first" as the pattern + and verify the current exception list rather than relying on a remembered name. +- `[2026-05-27]` ATS-scoring tools often paywall full results but expose enough for free to act on + — missing keywords and structural flags. The missing-keywords list is usually the most useful + free output. +- `[2026-06-09]` Paywalled full ATS reports tend to have diminishing returns per application — the + free-tier missing-keywords list and structural flags capture most of the actionable signal. + Worth paying for a scan only when optimizing across many applications at once, not per-role. +- `[2026-05-28]` Honest gap-acknowledgment in a cover letter (e.g. "I don't have production Ruby + experience yet; here's my ramp plan") tends to read as confidence rather than weakness. +- `[2026-05-28]` A strong-fit role can expire during an unnecessary extra-polish window. When the + fit is genuinely strong, submit fast rather than optimizing further. diff --git a/skills/jobstead/references/log.md b/skills/jobstead/references/log.md new file mode 100644 index 000000000..a7a982888 --- /dev/null +++ b/skills/jobstead/references/log.md @@ -0,0 +1,8 @@ +# Session Log + +Per-conversation activity audit — applications logged, lessons captured, profile or tracker +updates made. Append a dated entry at the end of a session if meaningful state accumulated; don't +read this file back in unless the applicant specifically asks what happened in a past session. + +Format: `[YYYY-MM-DD] Summary.` + diff --git a/skills/jobstead/references/profile.md b/skills/jobstead/references/profile.md new file mode 100644 index 000000000..8aa1c928e --- /dev/null +++ b/skills/jobstead/references/profile.md @@ -0,0 +1,61 @@ +# Applicant Profile + +Per-applicant state. Authoritative for the fit-check in SKILL.md §1, but not frozen — if the +conversation suggests a field may be stale (a repeated action inconsistent with a stored value, or +the applicant mentioning a change), ask whether it's changed and offer to update it. Never +overwrite a field silently; older values are only replaced on the applicant's explicit request. + +If this file is still blank when a session starts, ask whether the applicant has a resume to share +first — parsing it covers most fields in one pass. Only ask directly for whatever it doesn't cover +(typically work authorization and target roles/constraints). Let them know their answers are saved +here for next time. + +## Identity + +- **Name:** +- **Location:** +- **Citizenship:** +- **Work authorization status:** +- **Email:** +- **Phone:** + +## Public presence + +- + +## Career summary + +## Technical stack + +- **Cloud:** +- **Languages (production fluent):** +- **Languages (familiar, sparse production):** +- **Languages (not held):** +- **Frameworks:** +- **Data:** +- **DevOps / Architecture:** +- **AI tooling:** +- **Other specialized:** + +## Education + +## Languages + +## Target roles and constraints + +- **Open to:** +- **Industry preference:** +- **Geography:** +- **Salary expectations:** + +## Master resume + +*(filename or reference to the applicant's base resume)* + +## Long-term projects / deferred plans + +## Values / red flags + +- **Mission-aligned:** +- **Caution / discuss before applying:** +- **Hard pass:** diff --git a/skills/jobstead/references/tracker.md b/skills/jobstead/references/tracker.md new file mode 100644 index 000000000..e88200f86 --- /dev/null +++ b/skills/jobstead/references/tracker.md @@ -0,0 +1,53 @@ +# Application Tracker + +Per-conversation state, append-only in spirit — older entries are never lost to blank cells. This +file is write-hot and can grow large: when the applicant is only asking about one company, read +just that entry rather than the whole file, and confirm with the applicant before writing (don't +log an application silently). + +Status categories: **Reviewed and skipped** (fit-check failed) · **Deferred** (worth revisiting +later) · **Applied — awaiting response** · **Applied — in process** (recruiter call, technical +test, interview) · **Applied — rejected** · **Applied — offered / accepted / declined** · +**Expired before submission** (note the reason). + +## Applied — awaiting response + +| Company | Role | Date applied | Notes | +| --- | --- | --- | --- | +| | | | | + +## Applied — in process + +| Company | Role | Stage | Date | Notes | +| --- | --- | --- | --- | --- | +| | | | | | + +## Applied — rejected + +| Company | Role | Date | Likely cause | +| --- | --- | --- | --- | +| | | | | + +## Applied — offered / accepted / declined + +| Company | Role | Outcome | Date | Notes | +| --- | --- | --- | --- | --- | +| | | | | | + +## Deferred + +| Company | Role | Reason | +| --- | --- | --- | +| | | | + +## Expired before submission + +| Company | Role | Reason | +| --- | --- | --- | +| | | | + +## Reviewed and skipped + +| Company | Role | Reason | +| --- | --- | --- | +| | | |