How AI writes your cover letter in 30 seconds.

If you've applied to more than five jobs in your life, you know the feeling. You read the job ad. You open a blank document. You write "Dear hiring manager, I am writing to express my interest in the role of…" and then you stare at the cursor for fifteen minutes trying to remember which of your accomplishments are relevant.

Then you do it 49 more times.

Most job-application tools just put a templated form letter on top of this problem. ChatGPT writes you a generic "I'm a passionate candidate" paragraph. Indeed gives you a one-click apply that sends your CV with no message. Neither of those is a cover letter. They're noise.

A useful AI cover letter isn't just a text-generation problem. It's a matching problem solved by a generation step at the end. The matching is what makes it personal. The generation just turns the result into language.

Step 1 — Read the job ad as structured data

When you swipe right on a job in Justneed, the first thing happens before any text is generated. The system parses the job ad into a structured object:

// Extracted from a Klarna Senior Backend Engineer post
{
  title: "Senior Backend Engineer",
  company: "Klarna",
  required_skills: ["Go", "PostgreSQL", "Kubernetes", "gRPC"],
  nice_to_have:    ["Kafka", "Stripe API"],
  seniority:       "senior",
  team:            "Payments Infrastructure",
  notable_phrases: ["6+ years experience",
                   "lead architectural decisions",
                   "mentor junior engineers"],
  location:        "Stockholm",
  remote_policy:   "hybrid 2 days/week",
  company_values:  ["customer-obsessed", "ship fast"]
}

This isn't grep'ing keywords. An LLM (we use Google Gemini for this) reads the entire ad as a human would and extracts the structured fields. It catches things like "must lead architectural decisions" (a seniority signal) and "ship fast" (a company values signal) that simple keyword extraction would miss.

Step 2 — Read your Digital Skill ID as structured data

Your Digital Skill ID is already structured — that's the whole point. So it's already in a format the matcher can read directly:

{
  full_name:       "Astrid Larsson",
  current_role:    "Senior Backend Engineer",
  current_company: "Spotify",
  years_total:     8,
  skills: [
    { name: "Go",         verified_by: "employer", level: "expert" },
    { name: "PostgreSQL", verified_by: "coursera", level: "expert" },
    { name: "Kubernetes", verified_by: "credly",   level: "advanced" },
    ...
  ],
  experience: [
    { company: "Spotify",  role: "Senior Backend Eng", years: 4, verified: true },
    { company: "Truecaller", role: "Backend Eng",      years: 4, verified: true }
  ],
  identity_verified: true,
  identity_provider: "BankID"
}

Step 3 — Match (the hard part)

This is where the personalization actually happens. The matcher compares the job's requirements against your Skill ID's contents and builds a third object:

{
  match_score:        87,
  matching_skills:    ["Go", "PostgreSQL", "Kubernetes"],
  missing_skills:     ["gRPC"],
  seniority_alignment: "exact match (both senior)",
  notable_overlap:    "Spotify backend experience maps directly
                       to Klarna's payments infrastructure context.
                       Both companies value shipping fast.",
  pain_points_to_acknowledge: ["gRPC — has used REST + gRPC-Web
                                 but no production gRPC server"],
  unique_strengths:   ["8 years total senior backend",
                       "verified BankID identity",
                       "currently shipping production Go at Spotify"]
}

This object is the answer to the question "if you could brief a writer for one minute about why this person is right for this job, what would you say?" — generated automatically from two structured documents.

The reason AI-written cover letters usually sound generic is that they skip this step. They go from "here is a job ad" directly to "write a cover letter" and the LLM has to invent the matching on the fly. By building the match object first, we make the generation step easy.

Step 4 — Generate the letter

Now we hand the match object to Gemini with a prompt like:

"Write a 180-word cover letter from this candidate to this
 recruiter. Be specific about the 3 matching skills. Acknowledge
 the 1 missing skill briefly and confidently. Reference the
 Spotify-to-Klarna parallel. Sound like a senior engineer writing,
 not a marketing department. No 'passionate about' phrases."

What comes back, in about 2 seconds:

"Hi Klarna team — I'm a senior backend engineer at Spotify with 8 years of Go in production, including the payments-adjacent work on our wallet platform. Your payments-infrastructure role looks like a natural next step. Three of your four required skills (Go, PostgreSQL, Kubernetes) are what I've shipped against weekly for the past four years. I've used gRPC client-side but not yet operated a gRPC server in production — I'd close that gap fast given I'm already deep in protobuf at Spotify. Happy to send a code sample from the wallet team. Identity is BankID-verified inside Justneed if you want to confirm. — Astrid"

You read it, hit Send, the application goes out. The whole sequence took about 30 seconds from your swipe to the recruiter's inbox.

Why this isn't sketchy

Three concerns people raise about AI-written cover letters. The honest answers:

"Isn't this cheating?" No more than spell-check is. The personalization is yours — every fact in the letter came from your verified Digital Skill ID. The AI just put it in sentences. The recruiter can verify everything claimed.

"Won't every cover letter look the same?" No — each one is generated against a different match object. A backend role at Klarna gets a different letter from a frontend role at Spotify, even from the same candidate, because the matching skills and notable_overlap fields are different.

"What if the AI hallucinates skills I don't have?" It can't. The generation step is constrained to the structured Skill ID. If it isn't in your verified skill set, it doesn't appear in the letter.

What it means for time-to-apply

If you used to spend 20 minutes per cover letter, you spent 7 hours on a typical job-search cycle (20 applications). With the Digital Skill ID + AI cover letter loop, you spend about 10 minutes total for those same 20 applications — and the cover letters are better, because they're built on verified data instead of from memory.

That's the unlock. Not "AI writes a generic letter for you." It's "AI translates your verified credentials into the right pitch for each specific job, in seconds."