Upskill

Upskill

Overview

/upskill analyses jobs you have tracked and your current profile to identify skill gaps, then produces a heatmap of those gaps and a learning plan with concrete, web-searched study resources and a recommended study order.

Invocation

• /upskill — aggregate mode: analyses all jobs in job_search_tracker.csv
• /upskill <URL> — targeted mode: analyses a single job posting fetched from the URL

Step 1: Detect Mode

Check whether the user provided a URL argument:

• If the invocation was /upskill with no argument → aggregate mode
• If the invocation was /upskill <URL> → targeted mode, store the URL for Step 2

In targeted mode, derive a slug from the job title and company for the report filename (e.g. guardsix-senior-ai-engineer). You will fetch the posting in Step 2.

Step 2: Load Data

Aggregate mode

1. Read job_search_tracker.csv. Extract all rows. The columns are: date, company, sector, role, role_type, channel, status, contact_person, fit_rating, notes, cv_file, cover_letter_file, source
2. For each row, note the role, company, and fit_rating. The fit_rating column is a 0–100 score where 100 = perfect fit. You will use it to weight gaps — a lower fit rating means the role exposed more gaps.
3. Read .claude/skills/job-application-assistant/01-candidate-profile.md to get the candidate's current skills and experience.
4. Check upskill/ for the most recent aggregate report file (report-YYYY-MM-DD.md) — if one exists, note its date and load it for the diff in Step 8.

Targeted mode

1. Use WebFetch to retrieve the job posting from the URL.
2. Extract: job title, company, required skills, preferred skills, responsibilities, and any domain context.
3. Read .claude/skills/job-application-assistant/01-candidate-profile.md for the candidate's current skills.
4. No tracker data is used in targeted mode.

Step 3: Pass 1 — Hard Skill Diff

Extract required and preferred technical skills from each job source:

Aggregate mode

For each job row in the tracker, you do not have the full posting — use the role, sector, and notes columns to infer likely required skills. If the row has a source URL, you may optionally WebFetch it for more detail, but skip if the URL is missing or dead.

Build a skill frequency map: for each extracted skill, count how many jobs mention it. Then apply a fit weight: for each job, multiply the skill count contribution by (100 - fit_rating) / 100 — lower fit jobs contribute more to the gap score.

Final score for each skill: sum of (fit_weight × occurrence) across all jobs.

Targeted mode

Extract the explicit required and preferred skills from the fetched posting. Each skill gets equal weight (no fit weighting needed since there is only one job). List required skills before preferred skills, then sort alphabetically within each group.

Diff against profile

Remove any skill from the list that is already present in the candidate profile (01-candidate-profile.md). Be generous — if the profile mentions a skill in any form (e.g. "Python" covers "Python scripting"), remove it.

What remains is the hard skill gap list. In aggregate mode, rank by score descending. In targeted mode, list required skill gaps before preferred skill gaps, then sort alphabetically within each group.

Step 4: Pass 2 — LLM Synthesis

Now reason holistically about gaps that the hard skill diff would miss. Consider:

• Domain knowledge gaps: Does the candidate lack familiarity with the industry, domain, or problem space the jobs operate in? (e.g. cybersecurity, climate tech, quantitative finance)
• Soft skill gaps: Do the job descriptions emphasise ways of working, communication styles, or leadership expectations that the profile does not address?
• Tooling and process gaps: Frameworks, cloud services, methodologies (e.g. MLOps practices, CI/CD, agile at scale) that appear across jobs but are absent from the profile
• Credential or certification gaps: If multiple postings list a certification as preferred, flag it

Tag each synthesised gap as one of: [domain], [soft], [tooling], or [credential].

Do not duplicate gaps already captured in Pass 1. Only add what was missed.

In targeted mode, treat all synthesised gaps as arising from a single posting. Credential gaps can still be flagged if the single posting lists them as preferred or required.

Step 5: Build Gap Heatmap

Combine Pass 1 and Pass 2 results into a single prioritised table. Assign priority as follows:

• Critical: Hard skills with high frequency/weight scores, or domain gaps that appear across most tracked jobs
• High: Hard skills with moderate scores, or soft/tooling gaps that appear consistently
• Medium: Lower-frequency hard skills, or synthesised gaps that appeared in fewer roles
• Low: One-off mentions or minor nice-to-haves

Format:

Print this table to the terminal as an intermediate output before continuing to the learning plan.

In targeted mode, assign priority based on the job's own language: required skills → Critical or High, preferred skills → Medium, inferred gaps from LLM synthesis → Medium or Low.

Step 6: Build Learning Plan

For every Critical and High gap (and Medium gaps if fewer than 5 total gaps exist), produce a learning entry.

For each gap:

1. Run a WebSearch to find current, highly-rated study resources. Use queries like:

   • "best Kubernetes course 2025 site:reddit.com OR coursera.org OR fast.ai OR missing.csail.mit.edu"
   • "learn [skill] for [domain] 2025 recommendations" Include the current year in the query to avoid stale results.

2. Pick 2-3 resources from the search results. Prefer:

   • Courses with hands-on labs over lecture-only content
   • Official documentation for tooling gaps
   • Books for domain knowledge gaps
   • For each resource: name, URL, and one-line reason why it fits

3. Write a study direction tailored to the candidate's existing background. For example: if the candidate knows Docker, say "Skip the containers basics module — go straight to the orchestration and networking sections." Be specific about what to skip and where to start.

4. Estimate time to working proficiency (e.g. "20h", "40h for a solid foundation"). Be realistic — err toward more rather than less.

Group by theme

Group entries under theme headings rather than listing alphabetically. Example themes: Cloud & Infrastructure, MLOps, Domain Knowledge, Security, Soft Skills & Ways of Working, Certifications.

Example entry format:

### Cloud & Infrastructure

**Kubernetes** `[Hard]` — ~20h
- [Kubernetes for Absolute Beginners – KodeKloud](https://kodekloud.com) — hands-on labs, widely recommended on r/kubernetes for practical learners
- [Official Kubernetes Docs: Concepts](https://kubernetes.io/docs/concepts/) — use as reference once you have the basics
- [The Kubernetes Book – Nigel Poulton](https://leanpub.com/the-kubernetes-book) — concise, updated annually

Study direction: You already know Docker and containerisation — skip Chapter 1 on containers. Start at Pod scheduling and work through Services and Deployments. Focus on manifests and `kubectl` fluency before touching Helm.

Step 7: Suggest Study Order

After the learning plan, add a Suggested Study Order section. Number the topics in the recommended sequence. Apply these rules:

1. Dependencies first: If learning topic B requires topic A (e.g. "AWS networking" requires "AWS fundamentals"), place A before B and note the dependency.
2. Critical before High before Medium: Within a dependency tier, prioritise by gap priority.
3. Quick wins early: If a Medium gap is very fast (~5h) and boosts confidence, it can be placed early.
4. Domain knowledge last: Domain/soft gaps usually benefit from being studied alongside practical projects rather than up front.

Format:

## Suggested Study Order

| # | Topic | Type | Est. Time | Note |
|---|-------|------|-----------|------|
| 1 | Kubernetes | Hard | ~20h | Required before AWS EKS in step 3 |
| 2 | CI/CD pipelines | Tooling | ~10h | |
| 3 | AWS (advanced) | Hard | ~25h | Builds on step 1 |
| 4 | Security domain knowledge | Domain | ~15h | Study alongside a real project |

**Total estimated time: ~70h**

Step 8: Write and Save Report

Compose the report

Assemble the full report in this order:

# Upskill Report — YYYY-MM-DD
**Mode:** Aggregate (N jobs analysed) | Targeted: <Job Title> @ <Company>

---

## Since Last Report
<!-- Aggregate mode only. Omit section entirely in targeted mode or if no previous report exists. -->
**Gaps closed** (skills added to profile since <previous date>):
- ...

**New gaps** (from jobs tracked since <previous date>):
- ...

---

## Gap Heatmap

| Priority | Skill / Area | Type | Gap Source |
|----------|-------------|------|------------|
...

---

## Learning Plan

### <Theme>

**<Skill>** `[Type]` — ~Xh
- [Resource 1](url) — reason
- [Resource 2](url) — reason

Study direction: ...

---

## Suggested Study Order

| # | Topic | Type | Est. Time | Note |
...

**Total estimated time: ~Xh**

Save the report

• Aggregate: upskill/report-YYYY-MM-DD.md
• Targeted: upskill/report-YYYY-MM-DD-<company-slug>-<role-slug>.md
  • Slugify: lowercase, spaces → hyphens, strip special characters
  • Example: upskill/report-2026-04-20-guardsix-senior-ai-engineer.md

Use the Write tool to save the file.

Diff section (aggregate mode only)

If a previous aggregate report was loaded in Step 2:

• Gaps closed: Any skill in the previous report's heatmap that is now present in the candidate profile
• New gaps: Any skill in the current heatmap that was not in the previous report

If no previous report exists, omit the "Since Last Report" section entirely.

Confirm to user

After saving, print:

"Report saved to upskill/<filename>.md. Review it anytime to track your learning progress."

Important Rules

1. Never fabricate resources. Only cite resources found via actual WebSearch results. Do not invent course names, URLs, or authors.
2. Search with the current year. Include the year in every WebSearch query for resources so results stay fresh.
3. Targeted mode ignores the tracker. In targeted mode, analyse only the fetched posting. Do not load or reference job_search_tracker.csv.
4. Be generous with profile matching. If a skill appears in the candidate profile in any form, do not flag it as a gap. Avoid false positives.
5. Print the heatmap before the learning plan. Always show the intermediate heatmap table in the terminal before proceeding to resource search, so the user can see what you are working from.
6. Omit Low-priority gaps from the learning plan. List them in the heatmap for completeness, but do not generate study resources for them unless the user asks.
7. Always save the report. Do not skip the Write step even if the user seems satisfied with the terminal output.