company-hiring-intelligence

What this skill does

# Company Hiring Intelligence — Reverse-Engineer What a Company Is Building From Their Job Postings

You have access to the TinyFish CLI (`tinyfish`), a tool that runs browser automations from the terminal using natural language goals. This skill uses it to scrape a company's careers page, LinkedIn Jobs, and engineering blog in parallel, then synthesizes the raw hiring data into a strategic intelligence report.

A company quietly posting eight ML infra roles and two vector database engineers is telling you something. This skill reads those signals.

---

## Pre-flight Check (REQUIRED)

Before making any TinyFish call, always run BOTH checks:

**1. CLI installed?**

PowerShell:
```powershell
Get-Command tinyfish; tinyfish --version
```
bash/zsh:
```bash
which tinyfish && tinyfish --version || echo "TINYFISH_CLI_NOT_INSTALLED"
```

If not installed, stop and tell the user:
> Install the TinyFish CLI: `npm install -g @tiny-fish/cli`

**2. Authenticated?**

```bash
tinyfish auth status
```

If not authenticated, stop and tell the user:

> You need a TinyFish API key. Get one at: https://agent.tinyfish.ai/api-keys
>
> Then authenticate:
>
> **Option 1 — CLI login (interactive):**
> ```
> tinyfish auth login
> ```
>
> **Option 2 — bash/zsh (Mac/Linux):**
> ```bash
> export TINYFISH_API_KEY="your-key-here"
> ```
>
> **Option 3 — PowerShell (current session only):**
> ```powershell
> $env:TINYFISH_API_KEY="your-key-here"
> ```
>
> **Option 4 — PowerShell (persist across sessions):**
> ```powershell
> [System.Environment]::SetEnvironmentVariable("TINYFISH_API_KEY", "your-key-here", "User")
> ```
> Then close and reopen PowerShell.
>
> **Option 5 — Claude Code settings:** Add to `~/.claude/settings.local.json`:
> ```json
> {
>   "env": {
>     "TINYFISH_API_KEY": "your-key-here"
>   }
> }
> ```

Do NOT proceed until both checks pass.

---

## What This Skill Does

Given a company name (e.g. *"Notion"* or *"Mistral AI"*), this skill:

1. Scrapes the **company careers page** for all open roles — titles, teams, locations, and posting dates
2. Scrapes **LinkedIn Jobs** for the same company to cross-reference postings and surface duplicates or long-unfilled roles
3. Scrapes the company's **engineering blog** (if one exists) for recent technical posts that signal architectural direction

It then synthesizes all three into a structured intelligence report: which bets the company is making, which problems they haven't solved yet (chronic open roles), and which technologies are becoming load-bearing.

---

## Core Command

```bash
tinyfish agent run --sync --url <url> "<goal>"
```

### Key Flags

| Flag | Purpose |
|------|---------|
| `--url <url>` | Target URL to navigate to |
| `--sync` | Block until result is complete (required here — you need all data before synthesizing) |
| `--pretty` | Human-readable output for debugging |

---

## Step-by-Step Workflow

### Step 0 — Resolve the URLs

Before running agents, determine the three target URLs for the company:

| Source | How to find it |
|--------|---------------|
| Careers page | Usually `<company>.com/careers` or `<company>.com/jobs`. If unclear, search `"<company name>" careers site:company.com` first. |
| LinkedIn Jobs | Always: `https://www.linkedin.com/jobs/search/?keywords=<company+name>&f_C=<company_id>` — or simpler: `https://www.linkedin.com/company/<company-slug>/jobs/` |
| Engineering blog | Common patterns: `eng.<company>.com`, `<company>.com/blog/engineering`, `<company>.tech`, or search `"<company name>" engineering blog` |

If you cannot confidently resolve a URL, run a quick web search before proceeding. Do not guess.

---

### Step 1 — Scrape the Careers Page

```bash
tinyfish agent run --sync \
  --url "<company_careers_url>" \
  "Extract all visible job postings as JSON. For each role include: {\"title\": str, \"team\": str, \"location\": str, \"posted_date\": str, \"url\": str}. If pagination exists, navigate through all pages and collect every role before returning."
```

**Example for Notion:**
```bash
tinyfish agent run --sync \
  --url "https://www.notion.so/careers" \
  "Extract all visible job postings as JSON. For each role include: {\"title\": str, \"team\": str, \"location\": str, \"posted_date\": str, \"url\": str}. Navigate through all pages and collect every role."
```

---

### Step 2 — Scrape LinkedIn Jobs

```bash
tinyfish agent run --sync \
  --url "https://www.linkedin.com/company/<company-slug>/jobs/" \
  "Extract the top 25 job postings as JSON: [{\"title\": str, \"location\": str, \"posted_date\": str, \"seniority_level\": str, \"employment_type\": str, \"url\": str}]. If you encounter a login prompt, scroll past it or dismiss it and continue scraping the visible listings."
```

**Why LinkedIn matters:** LinkedIn shows `posted_date` more reliably and surfaces roles that have been reposted — a role listed as "Posted 3 weeks ago" that you saw listed on the careers page as "Posted 6 months ago" is a chronic open role, which signals either a hard-to-fill skill set or a team under construction.

---

### Step 3 — Scrape the Engineering Blog

```bash
tinyfish agent run --sync \
  --url "<engineering_blog_url>" \
  "Extract the 10 most recent blog posts as JSON: [{\"title\": str, \"author\": str, \"published_date\": str, \"url\": str, \"summary\": str (one sentence describing the technical topic)}]. Focus only on engineering or technical posts; skip product announcements or company news."
```

If no engineering blog exists, skip this step and note it in the report.

---

## Parallel Execution

All three sources are independent — run them simultaneously. Do NOT wait for one to finish before starting the next.

**bash/zsh — Parallel execution:**
```bash
# Fire all three simultaneously
tinyfish agent run --sync \
  --url "<careers_url>" \
  "Extract all job postings as JSON: [{\"title\": str, \"team\": str, \"location\": str, \"posted_date\": str, \"url\": str}]" \
  > /tmp/careers_results.json &

tinyfish agent run --sync \
  --url "https://www.linkedin.com/company/<slug>/jobs/" \
  "Extract top 25 job postings as JSON: [{\"title\": str, \"location\": str, \"posted_date\": str, \"seniority_level\": str, \"url\": str}]" \
  > /tmp/linkedin_results.json &

tinyfish agent run --sync \
  --url "<eng_blog_url>" \
  "Extract the 10 most recent engineering posts as JSON: [{\"title\": str, \"published_date\": str, \"url\": str, \"summary\": str}]" \
  > /tmp/blog_results.json &

wait  # Block until all three finish

cat /tmp/careers_results.json /tmp/linkedin_results.json /tmp/blog_results.json
```

**PowerShell — Parallel execution:**
```powershell
$careersJob = Start-Job {
    tinyfish agent run --sync `
      --url "<careers_url>" `
      "Extract all job postings as JSON: [{`"title`": str, `"team`": str, `"location`": str, `"posted_date`": str, `"url`": str}]"
}

$linkedinJob = Start-Job {
    tinyfish agent run --sync `
      --url "https://www.linkedin.com/company/<slug>/jobs/" `
      "Extract top 25 job postings as JSON: [{`"title`": str, `"location`": str, `"posted_date`": str, `"seniority_level`": str, `"url`": str}]"
}

$blogJob = Start-Job {
    tinyfish agent run --sync `
      --url "<eng_blog_url>" `
      "Extract 10 most recent engineering posts as JSON: [{`"title`": str, `"published_date`": str, `"url`": str, `"summary`": str}]"
}

Wait-Job $careersJob, $linkedinJob, $blogJob | Out-Null

$careersResults  = Receive-Job $careersJob
$linkedinResults = Receive-Job $linkedinJob
$blogResults     = Receive-Job $blogJob

Remove-Job $careersJob, $linkedinJob, $blogJob
```

---

## Step 4 — Extract Hiring Patterns Before Synthesizing

Before writing the report, run these four analyses against the raw JSON data. These are the signal extraction steps — the report is only as good as what you pull out here.

### 4a — Team Velocity (which teams are growing fastest?)
Group all roles by `team` field. Count roles per team. Rank by count descending. Teams with 4+ open roles are in active b