FreeCareer

Resume Builder

Paste your resume + a job post → a perfect, tailored 1-page .docx.

A guided prompt that turns your existing resume and a target job posting into a single-page, recruiter-ready Word document — tailored to the job, in a clean classic format, generated by code so the formatting is correct every time.

One click copies the full prompt. Paste it into ChatGPT or Claude and follow the steps below.

You are an expert resume writer and a careful document engineer. Your job: take my
current resume and a target job posting, then produce a polished, single-page resume
as a downloadable Microsoft Word (.docx) file, generated with code so the formatting
is exact and repeatable. Follow this process strictly and do not skip steps.

## STEP 1 — Collect inputs
Ask me to provide, in my next message:
  (a) my current resume — pasted text or an uploaded file, in any format; and
  (b) the FULL job posting — I will paste the entire job page, or give you a URL.
If I give a URL, fetch it and extract the real job description. If you cannot open the
URL, tell me exactly this: "I can't open that link. Please open the posting in your
browser, press Print, choose 'Save as PDF', and upload the PDF here." Then wait.

## STEP 2 — Understand the job
From the posting, extract: job title, seniority, the top responsibilities, the required
and preferred qualifications, and the most important keywords/skills (especially ones an
applicant-tracking system would scan for). Briefly list what the role most values.

## STEP 3 — Parse my resume
Extract my contact info, education, work experience, leadership/activities, skills, and
any awards. Note dates, titles, organizations, locations, and quantified achievements.

## STEP 4 — Interview me (only where needed)
Before writing, ask me concise questions IN A SHORT BATCH to fix any: gaps in dates,
missing metrics on important bullets, vague scope, contradictions, or qualifications the
job requires that my resume doesn't clearly show. Never invent facts. If something is
unknown, ask. If everything needed is present, skip straight to Step 5 and say so.

## STEP 5 — Tailor the content
Rewrite and reorder so the most job-relevant impact comes first. Mirror the posting's
wording where it's truthful. Lead bullets with strong past-tense verbs and concrete
results (numbers, %, $, scale). Naturally include the job's key terms (no keyword
stuffing). Keep it honest. Aim for content that fits on ONE page.

## STEP 6 — Generate the .docx with code (this is mandatory)
Write and run Python using python-docx to build the file. Use EXACTLY this format:

GLOBAL
- Page size US Letter (8.5in x 11in). Margins 0.5in on all four sides.
- Base font: a serif face — "Times New Roman" (fallback "Cambria"). Body size 10.5pt.
  Set the font name on the run's ascii, hAnsi AND cs (complex-script) font slots so it
  applies uniformly to every glyph — do this on the Normal style and on each run you
  build, otherwise some characters silently fall back to a default face.
- UNIFORM SPACING (this is what makes a templated resume read evenly): use ONE uniform
  line_spacing for the whole body (default 1.0). Within an entry, set space_after 0 on
  every line and every bullet. Create ALL vertical gaps ONLY via space_before:
  ~8pt of space_before on the first line of each entry, and ~9pt of space_before on
  section headers. Do NOT use per-bullet space_after to make gaps — mixing space_after
  into the body makes the spacing look irregular. (You may still use a small space_after
  on the name and contact lines.)

NAME (first line)
- Centered, bold, 16pt, the candidate's full name.

CONTACT (second line)
- Centered, 12pt, single line, fields separated by "  |  ":
  Location | Email | Phone | (optional) LinkedIn/portfolio.

SECTION HEADERS (e.g., EDUCATION, WORK EXPERIENCE, LEADERSHIP, ADDITIONAL INFORMATION)
- Uppercase, bold, 10.5pt (same size as the body — the rule and the caps give it weight,
  not a larger size). space_before ~9pt, space_after ~3pt.
- Add a full-width bottom border rule to the header paragraph (a thin horizontal line).
- Only include sections that have content; keep this order when present:
  EDUCATION, WORK EXPERIENCE, LEADERSHIP, ADDITIONAL INFORMATION.

ENTRIES (each job / school / activity) — use a RIGHT-ALIGNED TAB STOP, never a table:
- Add a right tab stop at 7.5in (page width minus margins) with alignment RIGHT.
- Line 1: Organization (bold) + tab + Location (bold, lands at right margin).
  Give this first line ~8pt of space_before (this is the gap that separates entries).
- Line 2: Role/Title (italic) + tab + Date range (italic, right).
- Then bullet lines (see below).
- ROBUST RIGHT-ALIGNED DATES: the right-tabbed date relies on the right tab stop at the
  content width (7.5in) to reach the margin. ALWAYS pair the right-tabbed date with a
  SHORT left-hand field (the org/name line), never with a line whose left text can grow
  long. If the left text is long enough to pass the tab stop, the tab collapses and the
  date stops aligning to the margin. Keep dates on the org/name line, not on a wordy line.

BULLETS
- Each bullet is its own paragraph: text starts with "• " then the content.
- Hanging indent: left_indent 0.13in, first_line_indent -0.13in (wrapped lines align
  under the text, not the bullet). Size 10.5pt. space_after 0, line_spacing 1.0 — the
  gap above the entry comes from the entry's first-line space_before, not from bullets.

ADDITIONAL INFORMATION
- Bold lead-in label then a pipe-separated inline list, e.g.:
  "Awards: National honor (2024) | Dean's List (2023)" with the label bold.
- Use italics for parenthetical sub-roles where natural.

ATS SAFETY (required)
- Real selectable text only. No text boxes. No tables for layout (dates via tab stops).
- Standard fonts. Logical heading order. No images of text.

OOXML SCHEMA ORDERING (engineering rule — required if you hand-build raw XML)
- python-docx exposes some properties (most importantly the section-header bottom border
  w:pBdr, and sometimes w:spacing / w:ind) only as raw OOXML. When you insert these child
  elements by hand, they MUST go in OOXML schema order. Strict renderers (Microsoft Word,
  Apple Pages) silently DROP any out-of-order child — most visibly your header rule just
  vanishes. python-docx will NOT warn you; the .docx still opens, it just looks wrong.
- Use a helper that inserts a child at its correct schema position instead of appending.
  Find the element if it exists; otherwise create it and insert it BEFORE the first
  existing child that comes later in the schema order (fall back to append):

    PPR_ORDER = ["w:pStyle", "w:keepNext", "w:keepLines", "w:pageBreakBefore",
        "w:framePr", "w:widowControl", "w:numPr", "w:suppressLineNumbers", "w:pBdr",
        "w:shd", "w:tabs", "w:suppressAutoHyphens", "w:kinsoku", "w:wordWrap",
        "w:overflowPunct", "w:topLinePunct", "w:autoSpaceDE", "w:autoSpaceDN",
        "w:bidi", "w:adjustRightInd", "w:snapToGrid", "w:spacing", "w:ind",
        "w:contextualSpacing", "w:mirrorIndents", "w:suppressOverlap", "w:jc",
        "w:textDirection", "w:textAlignment", "w:textboxTightWrap", "w:outlineLvl",
        "w:divId", "w:cnfStyle", "w:rPr", "w:sectPr", "w:pPrChange"]
    RPR_ORDER = ["w:rStyle", "w:rFonts", "w:b", "w:bCs", "w:i", "w:iCs", "w:caps",
        "w:smallCaps", "w:strike", "w:dstrike", "w:outline", "w:shadow", "w:emboss",
        "w:imprint", "w:noProof", "w:snapToGrid", "w:vanish", "w:webHidden",
        "w:color", "w:spacing", "w:w", "w:kern", "w:position", "w:sz", "w:szCs",
        "w:highlight", "w:u", "w:effect", "w:bdr", "w:shd", "w:fitText",
        "w:vertAlign", "w:rtl", "w:cs", "w:em", "w:lang"]

    def set_child(parent, order, tag, attrs=None):
        el = parent.find(qn(tag))
        if el is None:
            el = OxmlElement(tag)
            idx = order.index(tag)
            ref = None
            for ch in parent:
                for name in order[idx + 1:]:
                    if ch.tag == qn(name):
                        ref = ch
                        break
                if ref is not None:
                    break
            ref.addprevious(el) if ref is not None else parent.append(el)
        if attrs:
            for k, v in attrs.items():
                el.set(qn(k), v)
        return el

- Build the header rule with this helper: pBdr (use PPR_ORDER on the paragraph's pPr),
  then append a w:bottom child to it (w:val "single", w:sz "6", w:space "1",
  w:color "000000"). If you hand-build w:spacing or w:ind, insert them with the same
  helper and PPR_ORDER; for run properties (fonts, bold/italic, sz) use RPR_ORDER on rPr.

## STEP 7 — Fit to one page (single pass)
Estimate density from the amount of content and choose values within these ranges so the
page is comfortably filled but never overflows:
  body 10–11.5pt, name 16–20pt, contact 11–13pt, line_spacing 0.95–1.15,
  section header space_before 7–11pt, entry first-line space_before 6–10pt,
  margins 0.4–0.6in.
Keep the spacing UNIFORM while you scale: one line_spacing value for the whole body,
space_after 0 inside entries, and adjust density by moving the space_before values (entry
first-line and section header) together — not by sprinkling space_after onto bullets.
Sparse resume → larger sizes / looser spacing. Dense resume → smaller / tighter.
If content still cannot fit one page at the tightest settings, tell me which least
relevant items to cut (and why), then regenerate after I choose.

## STEP 8 — Render and verify (do not skip — this is a real loop)
Generating the .docx is not enough; python-docx writes whatever you tell it, including
bugs it won't flag. After generating, RENDER the file and inspect what a real viewer sees:

1. Prefer the ACTUAL target app. The reader opens the .docx in Microsoft Word (or Pages),
   so when you can, open it there and screenshot the real rendered page. Headless
   converters do not always match Word — LibreOffice in particular differs on borders,
   spacing and (for non-Latin scripts) text direction — so a `soffice` PDF is an advisory
   preview, not ground truth. As a fallback when no app is available:
     soffice --headless --convert-to pdf --outdir <output_dir> <file.docx>
   (LibreOffice; on some systems the binary is `libreoffice`.) Either way, VISUALLY inspect
   the rendered IMAGE — don't judge from extracted text.
2. Re-extract fonts and sizes programmatically (e.g. with pymupdf / fitz) and confirm
   against the spec — don't eyeball sizes, measure them.

Confirm each of these and state the result:
- exactly 1 page; margins correct; nothing overflows; no large empty gaps;
- font is the serif face everywhere (no fallback faces in the extracted font list);
- measured sizes are EXACTLY as specified: name 16pt, contact 12pt, body 10.5pt,
  section headers 10.5pt (or whatever Step 7 chose — but uniform and matching);
- bold is actually applied to org/section text and italic to titles/dates (check the
  flags in the extracted run data, not just by eye);
- the section-header bottom border rules are PRESENT in the rendered PDF (this is the
  first thing to vanish if XML went in out of schema order — see Step 6);
- entry org/location and role/date lines align left/right correctly and dates reach the
  right margin; bullets hang; spacing reads uniform; no header stranded at the page bottom;
- text is machine-readable / selectable in the PDF (re-extract it and confirm).

If ANY check fails, fix the code (or adjust the Step 7 values) and regenerate, then render
and verify again. Only proceed to Step 9 once every check passes.

## STEP 9 — Deliver
Give me the downloadable .docx file plus a 3–5 line summary of how you tailored it to the
job and anything I should double-check. Keep the tone confident and the resume truthful.

How to use

1Open ChatGPT (with code/Advanced Data Analysis) or Claude.
2Copy the full prompt below and paste it as your first message.
3When asked, paste your current resume (any format) and copy-paste the entire job-posting page.
4Answer the short interview — it fills gaps and resolves conflicts.
5Download the generated .docx, open it, and submit.