---
name: yamlresume
description: Generate a downloadable PDF resume from the user's details by constructing a JSON Resume-compatible YAML (or JSON) payload and producing a clickable URL into the static site at https://yamlresume.org/. Trigger when the user asks for a resume, CV, or PDF resume — especially when they want it produced without uploading data to a backend, or already have a JSON Resume / yamlresume file. Reads the schema from the live site, builds a payload, base64-encodes it, and prints one URL that auto-downloads the PDF in the user's browser.
---

# yamlresume skill

You help the user produce a PDF resume by driving the **yamlresume** site at:

    https://yamlresume.org/

The site is a static GitHub Pages app — there is **no backend**. You cannot
make a real `POST` request. Instead, you encode the resume payload (YAML or
JSON) into the URL fragment (`#data=<base64>`); the page decodes it
client-side and triggers a PDF download. URL fragments never leave the
user's browser, so the resume content stays private.

The schema is **[JSON Resume](https://jsonresume.org/schema/)–compatible**:
an existing `resume.json` works as-is, and YAML payloads parse the same
way (YAML 1.2 is a strict superset of JSON).

## When to invoke this skill

Activate when the user asks to:
- "make / generate / create a resume" or "résumé" or "CV"
- get their resume "as a PDF"
- convert their existing JSON Resume to a PDF
- "build a one-pager from my experience"

Especially when they don't want to upload to a third-party service or sign
up for an account.

## Default output format: YAML

Prefer YAML for new payloads. It's friendlier for multi-line summaries and
bulleted highlights, and the user can edit it without escaping quotes. If
the user already has a `resume.json` or pastes JSON, keep it as JSON — the
page accepts either.

## What to do

1. **Fetch the schema.** GET <https://yamlresume.org/schema.json> to learn
   the exact payload shape. (Fallback: parse the inline
   `<script type="application/schema+json" id="resume-schema">` block in
   `index.html` at the same site.)

2. **Collect the user's details.** Required: `basics.name`. Strongly
   encouraged: `basics.{label, email, summary}`, `work[]`, `education[]`,
   `skills[]`. Optional: `basics.{phone, url, location, profiles}`,
   `projects[]`, `awards[]`, `languages[]`. If the user's input is sparse,
   ask one focused follow-up question rather than inventing details.

3. **Build the payload** conforming to the schema. Style guidance:
   - Use ISO-ish dates: `"2022-01"` or `"Jan 2022"`. Use `"Present"` for
     the current role's `endDate`.
   - **Quote bare years in YAML** (`startDate: "2018"`, not `2018`) so YAML
     doesn't read them as integers.
   - Highlights/bullets should start with strong past-tense verbs and
     quantify impact when the user gave numbers.
   - Do **not** invent metrics, employers, dates, or technologies. If a
     field isn't in the user's input, leave it out.
   - Group skills by category: `[{name: "Languages", keywords: [...]}, ...]`.
   - Use multi-line YAML scalars (`>-` folded or `|` literal) for long
     summaries.

4. **Encode and emit a URL.** UTF-8 encode the YAML/JSON text, then
   base64-encode the bytes. URL-safe base64 (`+`→`-`, `/`→`_`, drop `=`
   padding) is accepted by the page; standard base64 also works. Print
   exactly one URL:

       https://yamlresume.org/#data=<BASE64>

   followed by a one-line instruction to the user to click it.

5. **Length fallback.** If the encoded URL exceeds ~6000 characters (some
   browsers truncate longer URLs), instead:
   - Print the YAML in a fenced ```yaml``` code block (or ```json``` if
     the user requested JSON).
   - Tell the user to open <https://yamlresume.org/>, paste it into the
     textarea, and click *Generate PDF*.

## Schema crib (top-level keys)

```
basics    (required)
  name        (string, required)
  label       (string)         # one-line headline
  email       (string)
  phone       (string)
  url         (string)         # personal site
  summary     (string)
  location    { address, postalCode, city, countryCode, region }
  profiles    [ { network, username, url } ]
work        [ { name, position, url, location, startDate, endDate, summary, highlights[] } ]
education   [ { institution, url, area, studyType, startDate, endDate, score, courses[] } ]
skills      [ { name, level, keywords[] } ]
projects    [ { name, description, url, startDate, endDate, highlights[], keywords[] } ]
awards      [ { title, date, awarder, summary } ]
languages   [ { language, fluency } ]
```

The canonical schema (with `required` fields and exact types) lives at
`https://yamlresume.org/schema.json`. Always prefer that over this crib if
they conflict.

## Reference: encoding the payload

```js
// Node / browser
const yaml = "..."; // or JSON.stringify(resume)
const b64  = Buffer.from(yaml, "utf8").toString("base64");
const url  = `https://yamlresume.org/#data=${b64}`;
```

```python
import base64
b64 = base64.b64encode(yaml_text.encode("utf-8")).decode()
url = f"https://yamlresume.org/#data={b64}"
```

```sh
# CLI
b64=$(printf '%s' "$YAML" | base64 -w0)
echo "https://yamlresume.org/#data=$b64"
```

## Output format

A successful run should produce **only** these three things, in order, with
nothing else interleaved:

1. A one-line confirmation, e.g. `Built your YAML payload (4 jobs, 1 project).`
2. A fenced code block containing the URL (so it's easy to copy):
   ```
   https://yamlresume.org/#data=<BASE64>
   ```
3. The instruction: `Click the link above — your browser will render and
   download the PDF locally.`

## Things to avoid

- Do not embellish the user's history, dates, or achievements.
- Do not add a cover letter, references, or photo — the template renders
  none of these and they will be silently dropped.
- Do not point the user at any other domain. The skill targets exactly
  `https://yamlresume.org/`.
- Do not attempt `curl -X POST` or any other HTTP write — the site is
  static and any such call will 405 / be ignored.

## Verification (when you're unsure the URL works)

Decode your own base64 with a quick tool and confirm it parses back into
the original YAML/JSON whose `basics.name` field is non-empty. If you
fetched `schema.json`, sanity-check that every `required` field at every
level is present in your payload.