Software Engineering Career / US Tech Jobs Beginner

27 ChatGPT prompts for software engineers to rewrite resumes for US tech roles

If you’re a software engineer sending out US tech resumes in 2026 and barely hearing back, the problem is almost never your skill set. It’s the resume. Most engineer resumes get chewed up by the ATS, glossed over by recruiters in six seconds, or quietly filtered out by a hiring manager skimming on a phone. The fix isn’t a prettier template. It’s rewriting the resume so the right keywords, outcomes, and stories show up exactly where the reader - human or AI - expects them.

This is a copy-paste prompt library. I’m giving you 27 ChatGPT prompts for software engineer US tech resume work, all of which I’ve battle-tested against real US job descriptions, Greenhouse and Lever pipelines, and the way AI/LLM-aware recruiters now scan resumes in 2026. You’ll get audit prompts, headline prompts, bullet-rewrite prompts, skills prompts, project prompts, and tailoring prompts. Each one is multi-line, structured, and includes a ready example plus a pro tip.

Pull quote: “In 2026, the US job market had 7.6 million open roles in a single month (April, JOLTS) - but software engineers still get ghosted, because most resumes fail the 6-second scan and the 75% ATS filter.” - SuperFresh AI, June 2026

I’ll also give you a 4-stage engineer-resume anatomy, a 14-day “first 3 calls” sprint, and a comparison table that maps each prompt to the resume section it fixes. By the end, you’ll have a rewritten, ATS-clean, FAANG-shaped, AI-aware resume - without hiring a coach.

Let’s go.

Why 75% of resumes die in the ATS (with 2026 stat)

The Applicant Tracking System (ATS) is software that filters, parses, and ranks resumes before a human ever sees them. Every big US tech company - Google, Meta, Amazon, Netflix, Stripe, Anthropic, OpenAI, smaller startups running Greenhouse or Lever, and giant banks running Workday or Taleo - runs your resume through one. If your resume is a PNG, has a fancy two-column layout, or buries the keywords, it can score a 0 and never reach a recruiter. Industry coverage in 2026 (Resumeworded, Jobscan, Simplify, and Recruiter surveys) keeps converging on a single number: roughly 75% of resumes get rejected by the ATS before a human looks at them.

The 2026 context makes this worse, not easier. The US unemployment rate was 4.3% in May 2026, per the BLS Employment Situation release on June 5, 2026, and the JOLTS report for April 2026 showed 7,618,000 open jobs on the last business day of the month. Software developer roles specifically are projected to grow 15% from 2024 to 2034 - much faster than the 3% average for all occupations - with about 129,200 openings per year, per the BLS Occupational Outlook Handbook for Software Developers. Sounds great, right? More roles than ever, more candidates than ever, and a screening layer that didn’t exist 15 years ago.

Recruiters in 2026 don’t even read most resumes end-to-end. They use resume parsers (Sovren, RChilli, Affinda), keyword matchers (Jobscan, Resume Worded), and increasingly an LLM-based summary to decide if you get a 6-second eyeball. If your bullets are “Worked on backend services” instead of “Cut p99 API latency from 850ms to 190ms for 2.4M MAU via Postgres index tuning and Go worker refactor”, you’ve already lost. The prompts below fix exactly that.

The 4-stage engineer-resume anatomy

A great US tech resume has four stages: audit the JD, rewrite the headline, rewrite the bullets, and rewrite the projects/skills. Most engineers skip straight to “make it look nice.” That’s backwards. The order matters because each stage builds on the last, and the AI gets better with context. Here’s the anatomy I teach - and what each ChatGPT prompt in this library does:

Audit & target stage. Paste the job description and your current resume. Ask ChatGPT to extract must-have keywords, compare against your experience, and flag the gap. This produces a “target keyword list” you’ll sprinkle through the rest of the doc.
Headline & summary stage. Rewrite the top 3 lines of your resume (name + title + tagline) so a recruiter knows your level, stack, and signature impact in 6 seconds. The “Senior Backend Engineer | Go, Postgres, Kubernetes | Cut p99 latency 4× for 2.4M MAU” format.
Bullets & impact stage. Rewrite every job’s bullets using the XYZ formula (“Accomplished X, as measured by Y, by doing Z”) from Laszlo Bock’s Work Rules! and the STAR method. The result: dense, quantified, scannable bullets.
Skills, projects, and tailoring stage. Build a clean skills block, add 2–4 side projects that match the JD, and tailor the entire resume to each role so the keyword density lands at 70–85% match on Jobscan without sounding stuffed.

The 27 prompts below are mapped to these four stages. Stage 1 is prompts 1–5. Stage 2 is prompts 6–10. Stage 3 is prompts 11–16. Stage 4 is prompts 17–25. Final 26 and 27 are ATS + LLM-aware tailored rewrites for specific companies.

SECTION 1: Audit & target prompts (prompts 1–5)

Audit prompts are the most important prompts in this whole library. They give ChatGPT the “source of truth” (the job description) and your “current state” (your old resume) and ask it to compute the gap. Without this, every later prompt is just style.

Prompt 1 - JD keyword extractor

Purpose: Pull every must-have and nice-to-have keyword, tool, and seniority signal from a US tech job description, in clean buckets, so you know what to put in your resume.

Prompt:

You are a senior technical recruiter who has placed 500+ software engineers at US
tech companies (FAANG, top unicorns, growth-stage startups). I will paste a US tech
job description below. Extract from it:

1. MUST-HAVE technical skills (hard skills, languages, frameworks, cloud, DBs).
2. NICE-TO-HAVE technical skills.
3. Required years of experience and seniority signal (Junior / Mid / Senior / Staff).
4. Domain context (fintech, healthtech, devtools, AI/ML infra, etc.).
5. Soft skills the JD emphasizes (leadership, mentoring, cross-functional, etc.).
6. 5 power verbs the JD implies I should use in my resume bullets.
7. 3 "vague" requirements that usually mean something specific in practice
   (e.g., "fast-paced environment" = on-call, "ownership" = 0-to-1, "rock-solid" = SLOs).

Return the output as 7 numbered sections. Use bullet lists. Be specific, do not
paraphrase the JD into generic phrases. If a tool name appears 2+ times, bold it.

Here is the job description:
<PASTE JD HERE>

Example output (excerpt for a Stripe-style Senior Backend Engineer JD):

MUST-HAVE: Ruby, Go, PostgreSQL, Kafka, Kubernetes, gRPC, AWS, Terraform, Datadog.
NICE-TO-HAVE: Rust, gRPC, Temporal, Snowflake, ClickHouse.
Seniority: Senior (5+ years), IC track. “Staff” mentioned only in growth path.
Domain: payments / fintech / PCI-DSS.
Soft skills: cross-functional collaboration, written communication, on-call comfort.
Power verbs: designed, scaled, led, shipped, debugged.
Vague → specific: “fast-paced” = on-call rotation; “ownership” = end-to-end service; “rock-solid” = 99.99% SLO.

Pro tip: Save the output of this prompt as jd_target.md in your job-search folder. Every later prompt should reference it. This is your “north star” doc for the application.

Prompt 2 - Resume vs JD gap analyzer

Purpose: Compare your current resume against the JD and get a brutally honest gap list with specific fixes.

Prompt:

Act as a technical hiring manager at a US tech company. I will paste a US tech job
description and my current software engineer resume. Your job:

A) List every MUST-HAVE keyword from the JD that is MISSING or WEAKLY represented
   in my resume. Quote my current bullet (or "not present") and tell me the
   strongest way to add it without lying.
B) List every MUST-HAVE keyword that IS present but buried - give me the section
   it's in and suggest where to surface it (e.g., "move 'Kubernetes' from Skills
   to the headline").
C) Identify 3 bullets in my resume that are too vague ("worked on X", "helped
   with Y") and rewrite each one using the XYZ formula:
   "Accomplished [X], as measured by [Y], by doing [Z]."
D) Flag anything in my resume that an ATS would choke on: tables, columns, headers
   in images, fancy icons, non-standard section names.

Output as 4 sections (A, B, C, D). Be direct, no sugarcoating. I can take it.

JOB DESCRIPTION:
<PASTE JD>

MY CURRENT RESUME:
<PASTE RESUME>

Example output (excerpt):

A. Missing: Kafka, gRPC, PCI-DSS, on-call. None appear in your resume. Add Kafka to the “Senior Backend, Acme” bullets (you used it but didn’t say so). Add an explicit “On-call: 1-week rotation for 14 services” line under that job.
B. Buried: “Go” is in Skills but not in any bullet headline. Add it to the first bullet of your current role.
C. Vague bullet: “Helped scale the payments service.” → Rewrite: “Scaled payments service from 200 RPS to 4,500 RPS (22×) by sharding Postgres and introducing a Go-based idempotency layer, holding p99 under 220ms during Black Friday.”
D. ATS risk: Your resume uses a two-column layout with sidebar - many ATS parsers will read column 2 first and reorder your name/contact info. Switch to a single column.

Pro tip: Run this prompt for every job you apply to. Expect a 20–30% rewrite of your master resume per application. That’s normal - it means the resume is being tailored, not copy-pasted.

Prompt 3 - Recruiter-screen sim (“Top-of-Funnel Recruiter Screen” by Greenhouse)

Purpose: Stress-test your resume the way a real recruiter will read it: 6 seconds, top to bottom, on a phone.

Prompt:

You are a US tech recruiter doing a 6-second Top-of-Funnel Recruiter Screen
(the same concept Greenhouse's hiring docs describe). I will paste my resume.
Do this:

1. Spend 6 simulated seconds. Tell me exactly what stuck in your head.
2. Tell me my "level signal" (Junior / Mid / Senior / Staff / Principal / Manager)
   based ONLY on the resume, and quote 2-3 lines that made you decide that.
3. List the 3 most senior / impressive things on the resume in order.
4. List the 3 weakest / most forgettable bullets in order, and the rewrite
   you'd use to fix them.
5. Give me one sentence I could add to the headline that would make a recruiter
   stop scrolling.

Be honest. Recruiters in 2026 see 200+ resumes/week. Most get 6 seconds.

MY RESUME:
<PASTE RESUME>

Example output:

6-second takeaway: “Mid-to-senior backend, Go, scaled something 10×, but I can’t tell the company or the impact cleanly.”
Level signal: Senior (5–7 years implied). “Led migration of 14 services” + “On-call for 22 services” are the giveaway.
Top 3: the latency cut, the on-call line, the open-source maintainer mention.
Weakest 3: “Worked with product managers to deliver features” (could be a junior), “Helped improve performance” (how much?), “Participated in code reviews” (every engineer does this - delete).
Headline fix: “Senior Backend Engineer | Go, Postgres, Kafka | Cut p99 4×, owned $40M GMV checkout pipeline.”

Pro tip: If the recruiter’s 6-second level guess is lower than your actual level, your resume is “leveling down” you. That’s the most expensive bug in an engineer resume. Fix the bullets that scream “junior” first.

Prompt 4 - Seniority calibration prompt

Purpose: Make sure your resume reads at the level you’re applying for. Junior applying to mid? Mid to senior? Senior to staff? Each transition has telltale bullets.

Prompt:

I am applying for [TARGET LEVEL: e.g., Senior Backend Engineer / Staff Engineer /
Engineering Manager] roles at US tech companies in 2026. My current resume is
below. Two tasks:

1. Compare my resume's "level signal" to [TARGET LEVEL] and tell me the gap in
   plain English (e.g., "Your resume currently reads as Mid. To read as Senior
   you need 2 more bullets showing scope, and 1 more showing leadership.").
2. Give me 5 specific bullet rewrites I should add or replace, calibrated to
   [TARGET LEVEL]:
   - If TARGET = Senior, add bullets about: scope (services owned), business
     impact ($/users/GMV), and on-call.
   - If TARGET = Staff, add bullets about: cross-team influence, technical
     strategy, mentoring, and 0-to-1 work.
   - If TARGET = EM, add bullets about: 1:1s, hiring, performance calibration,
     org design, and team velocity.
3. For each rewrite, give me a "before" (current vague version) and an "after"
   (XYZ-formula version) so I can drop it straight in.

JOB DESCRIPTION FOR THE TARGET ROLE (optional but helpful):
<PASTE JD>

MY RESUME:
<PASTE RESUME>

Example output (excerpt - Mid → Senior):

Gap: Your resume reads as Mid (3–4 yrs). To read as Senior you need to show scope (you owned X end-to-end) and impact (your work moved a number, not a feature).
Bullet rewrites:
- Before: “Built internal admin dashboard.”
- After (Senior): “Owned the internal admin platform serving 240 internal users across 6 teams, cutting ops ticket volume 38% and saving ~14 eng-hours/week.”

Pro tip: Use the same prompt twice - once targeting the next level up from your current role. That gives you a “growth resume” you can keep in your back pocket for 6 months from now.

Prompt 5 - “Reverse chronological” sanity check

Purpose: The reverse chronological resume is the US tech default - most recent job first, going back ~10–15 years. This prompt checks yours against the convention.

Prompt:

I will paste my software engineer resume. Audit it for US tech reverse-chronological
convention in 2026. Check and report:

1. Is the order strictly reverse-chronological (most recent job first)?
   Flag any out-of-order entries.
2. Are dates formatted as "Mon YYYY – Mon YYYY" (e.g., "Mar 2022 – Present")?
   US tech recruiters expect this, not "2022/03" or "Q1 2022".
3. Does each role have: Company, Location (City, State or "Remote"), Title, Dates,
   and 3-6 bullets? Flag any role missing any of these.
4. Are there any gaps >6 months? If yes, suggest how to explain them honestly
   (e.g., "Career break - caregiving", "Contract role - listed under Projects").
5. Are there roles from >15 years ago that are eating space? Suggest a "Earlier
   Career" rollup if so.
6. Is there a consistent verb tense? Past tense for old roles, present tense
   for current role.

Output as 6 numbered sections. Be specific. Give me the exact line to change.

MY RESUME:
<PASTE RESUME>

Example output:

Order is correct.
Date format: inconsistent - “Mar 2022 - Present” uses a hyphen, but “Aug 2019–Dec 2021” uses an en-dash. Pick one (en-dash is more US-tech-standard).
“Acme Corp” role is missing location. Add “Remote” or “San Francisco, CA”.
Gap: Dec 2021 – Mar 2022. Suggest: “Career break, professional upskilling (AWS Solutions Architect cert + System Design deep-dive)”.
The 2009–2012 role is taking 8 lines. Roll it up: “Software Engineer (3 roles) - 2009–2012”.

Pro tip: US tech resumes are 1 page for 0–7 years of experience, 1.5 pages for 7–12 years, and 2 pages for 12+ years. If yours is 3 pages, you’re padding. Cut it.

SECTION 2: Summary & headline prompts (prompts 6–10)

Your headline is the only thing a recruiter is guaranteed to read. It’s the 1–3 lines right under your name. It must answer: who are you, what’s your stack, and what’s the one number that proves you can do the job. The “Senior Backend Engineer | Go, Postgres, Kubernetes | Cut p99 latency 4× for 2.4M MAU” format is the gold standard for US tech in 2026 because it parallel-parses for both humans and LLMs.

Prompt 6 - Headline generator from scratch

Purpose: Generate 5 candidate headlines (3-line, 1-line, and 2-line variants) for your current level and target role.

Prompt:

You are a US tech resume strategist. Generate 5 resume headline options for me
based on the inputs below. Mix of formats:

A) 3-line headline (Name-level-line + stack-line + impact-line)
B) 1-line "elevator pitch" headline (≤140 chars, single line)
C) 2-line headline that mixes seniority + signature metric
D) "FAANG-style" title-flush headline (e.g., "Staff Software Engineer - Distributed
   Systems | ex-Google")
E) "Startup-style" headline (more colorful, e.g., "Backend engineer who likes
   traffic spikes and Kafka")

For each option, give me:
- The headline itself
- A 1-sentence note on which kind of company / role it's best for
- A 1-sentence note on the underlying format pattern I can reuse

Inputs:
- Current title: [YOUR CURRENT TITLE]
- Years of experience: [N]
- Primary stack: [LANG, FRAMEWORK, DB, CLOUD]
- Top signature metric (pick the most impressive single number): [METRIC]
- Target role: [TITLE] at [COMPANY TYPE - FAANG / unicorn / growth startup / fintech]
- Location: [CITY, STATE or "Remote"]

Do NOT include the name. Output the 5 options in a table.

Example output (excerpt - 5 yrs, Go/Postgres, cut latency 4×):

#	Format	Headline	Best for
A	3-line	Senior Backend Engineer - Go, Postgres, Kafka. Cut p99 latency 4× for 2.4M MAU. Owned 14 services end-to-end.	Mid-to-senior IC at any US tech company
B	1-line	Senior Backend (Go, Kafka) · p99 ↓4× · 14 services owned · ex-Stripe	Job boards, LinkedIn headline, GitHub README
C	2-line	Senior Backend Engineer · Go/Postgres/Kafka. Cut p99 latency 4×, held it under 200ms through 2× Black Friday traffic.	US tech resume top section
D	FAANG-style	Senior Software Engineer - Distributed Systems & Payments · ex-Stripe, ex-Airbnb.	FAANG, OpenAI, Anthropic, Netflix
E	Startup-style	Backend engineer who likes traffic spikes, Kafka, and the words “incident postmortem”.	Early-stage startup, 5–50 people

Pro tip: Use option A as your resume headline, option B as your LinkedIn headline, and option D for cold outreach to FAANG recruiters. One source of truth, three formats.

Prompt 7 - Summary paragraph (optional, but powerful for senior+)

Purpose: Generate a 3–4 sentence “Summary” or “Professional Profile” block for senior+ engineers. Skip this if you’re under 5 years of experience - it can hurt more than help.

Prompt:

Write a 3-4 sentence professional summary for the top of my US tech resume. The
summary must:

- Open with my title and years of experience (e.g., "Senior Backend Engineer
  with 8 years of experience building high-throughput distributed systems.").
- Mention 2-3 specific tools/domains I work in.
- Include 1 quantified impact number (users, RPS, GMV, $, latency, etc.).
- End with a "what I'm looking for" line that signals intent without sounding
  desperate (e.g., "Looking for Staff IC roles in fintech or devtools.").

Tone: confident, plain English, no buzzwords, no "passionate", no "rockstar",
no "guru". First person allowed but not required.

Inputs:
- Title + years: [TITLE, N YEARS]
- Stack: [LIST]
- Top impact: [METRIC + CONTEXT]
- Target: [TARGET ROLE TYPE]
- One unique signal: [E.G., "ex-FAANG", "open-source maintainer of X with 12k stars", "author of Y book"]

Example output:

Senior Backend Engineer with 8 years building high-throughput distributed systems in Go, Postgres, and Kafka. Owned a $40M GMV checkout pipeline end-to-end at Acme, cutting p99 latency 4× and holding it through 2× Black Friday traffic. Ex-Stripe, ex-OpenAI intern. Looking for Staff IC roles in fintech, payments, or devtools.

Pro tip: If you’re early-career, skip the summary. Recruiters will assume you’re junior. Let the bullets do the talking.

Prompt 8 - “One-liner tagline” for GitHub, LinkedIn, and cold email

Purpose: A version of the headline that fits in 90–140 characters and works outside the resume - LinkedIn headline, GitHub bio, cold email subject.

Prompt:

Write 3 versions of a one-liner tagline for me. Constraints:

- Version 1: 90 characters max (fits in a LinkedIn headline).
- Version 2: 140 characters max (fits in a cold email subject + body teaser).
- Version 3: 220 characters max (fits in a GitHub README or Twitter bio).

All three must include: title, top 2 stack items, and one signature metric.

Tone: not cringe. No "building the future", no "passionate about". Just clean
signal.

Inputs:
- Title: [TITLE]
- Stack: [STACK]
- Signature metric: [METRIC]
- Voice: [E.G., "plain", "warm", "engineer-y", "ex-FAANG, dry humor"]

Example output (3 versions, all for the same engineer):

v1 (90c): Senior Backend (Go, Kafka). Cut p99 4× at Acme. ex-Stripe. Staff-track IC, fintech.
v2 (140c): Senior Backend Engineer · Go, Kafka, Postgres. Cut p99 latency 4×, owned $40M GMV pipeline, ex-Stripe. Open to Staff IC in fintech/devtools.
v3 (220c): Senior Backend Engineer building high-throughput distributed systems in Go, Kafka, and Postgres. Most recently cut p99 latency 4× for Acme’s $40M GMV checkout pipeline. ex-Stripe, ex-OpenAI intern. Open to Staff IC roles in fintech or devtools.

Pro tip: Test your one-liner by sending it to a senior engineer friend and asking “what does this person do?” If they can’t say it in 5 seconds, rewrite.

Prompt 9 - Title calibration prompt

Purpose: Make sure your title on the resume matches US tech norms. “Software Engineer” is generic. “Backend Engineer” is clearer. “Senior Software Engineer (Distributed Systems)” is sharper.

Prompt:

My current resume title is "[YOUR CURRENT TITLE]". I am targeting [TARGET ROLE]
at [COMPANY TYPE]. Two questions:

1. Does my current title under-sell, over-sell, or mismatch the US tech market
   in 2026? Quote 2-3 things from the JD that suggest a different title.
2. Suggest 3 alternative titles I could use, with the trade-offs of each
   (e.g., "Backend Engineer" is more searchable than "Platform Engineer" for
   some roles, even if the work is identical).
3. Tell me if I should add a parenthetical specialization (e.g., "Senior Software
   Engineer (Distributed Systems)") or keep the title clean.

Output as 3 numbered sections.

Example output:

Current title “Software Engineer” is correct but generic. The JD says “Senior Backend Engineer (Payments)” - that’s a sharper match.
Alternatives:
- “Senior Backend Engineer” - most searchable for this JD.
- “Senior Software Engineer, Payments Platform” - matches the JD team name.
- “Senior Software Engineer (Distributed Systems)” - broader, future-proof.
Recommendation: Use “Senior Backend Engineer” as the title, and add the team/specialization in the first bullet: “Member of Payments Platform team; owned 3 services.”

Pro tip: Don’t lie about your title. But you can align it. If your official title was “Software Engineer II” at Acme, list it as “Software Engineer II (Backend)” on the resume - same official title, more searchable.

Prompt 10 - “Why me” 30-second pitch (for cover letters and recruiter calls)

Purpose: A 30-second verbal pitch that doubles as the basis for a cover letter paragraph. Useful for recruiter screens and for the top of your LinkedIn “About” section.

Prompt:

Write a 30-second spoken pitch I can use on a recruiter screen or as the basis
for a cover letter paragraph. Constraints:

- 75-90 words, plain English, sounds like a human talking, not a press release.
- Open with: who I am + years of experience.
- Middle: 1 specific impact story (XYZ formula).
- End: what I'm looking for (target role type).

Then, give me a 3-sentence LinkedIn "About" version, and a 1-sentence cold
email opener version, all derived from the same pitch.

Inputs:
- Who I am: [TITLE, N YEARS]
- Impact story: [XYZ METRIC]
- What I want: [TARGET ROLE TYPE]
- 1 unique signal: [E.G., "open-source maintainer", "ex-FAANG", "wrote a book"]

Example output (75-word pitch):

“I’m a senior backend engineer with 8 years of experience in Go, Postgres, and Kafka. Most recently at Acme, I owned the $40M GMV checkout pipeline end-to-end and cut p99 latency 4× - held it under 200ms through 2× Black Friday traffic. Before Acme I was at Stripe on the payments-core team. I’m looking for Staff IC roles in fintech or devtools where distributed systems is the actual job.”

LinkedIn About (3 sentences): Senior backend engineer with 8 years in Go, Kafka, and Postgres. Most recently owned Acme’s $40M GMV checkout pipeline, cutting p99 latency 4× and holding it through 2× Black Friday traffic. Looking for Staff IC roles in fintech or devtools.

Cold email opener (1 sentence): Hi [Name] - I’m a senior backend engineer (Go, Kafka, Postgres) with 8 yrs at Stripe/Acme, most recently cut p99 4× on a $40M GMV pipeline; exploring Staff IC roles in fintech and would love 15 min.

Pro tip: Rehearse the 75-word pitch out loud 3 times before a recruiter screen. If you can say it without stumbling, you’ve internalized the story.

SECTION 3: Bullet & impact prompts (prompts 11–16)

Bullets are the body of the resume. They must be dense, quantified, and scannable. The two most-cited formats in US tech are the XYZ formula (“Accomplished X, as measured by Y, by doing Z”) from Laszlo Bock (former SVP of People at Google, Work Rules!) and the STAR method (Situation, Task, Action, Result), which is more common in management-track resumes. The prompts below use XYZ because it maps cleanly onto a single bullet.

Prompt 11 - XYZ bullet rewriter (the workhorse)

Purpose: Take any vague resume bullet and turn it into a quantified, scannable, XYZ-formula bullet.

Prompt:

You are a US tech resume writer who specializes in the "XYZ formula" popularized
by Laszlo Bock (former Google SVP of People, author of Work Rules!).

I will paste one or more vague bullets from my current resume. For each bullet:

1. Identify what's missing (a number? an action verb? a business context? a tool?).
2. Ask me up to 3 clarifying questions ONLY if you absolutely need them - otherwise
   infer reasonable numbers from context and mark them with [VERIFY] so I can
   confirm.
3. Rewrite the bullet in the XYZ format:
   "Accomplished [X], as measured by [Y], by doing [Z]."
4. Give me 2 alternative phrasings (one punchy, one more formal).
5. Give me a 1-line "anti-pattern" note explaining what was wrong with the
   original bullet (so I learn the pattern, not just the output).

VAGUE BULLETS:
<PASTE BULLETS>

Example output (1 bullet):

Original: “Worked on improving backend performance.”
Missing: number, action verb, tool, business context.
Rewrite (XYZ): “Cut p99 API latency from 850ms to 190ms (4.5×) for 14 services serving 2.4M MAU, by profiling with Pyroscope and rewriting the hot path in Go.”
Alternative punchy: “Slashed p99 from 850ms to 190ms across 14 services via Go hot-path rewrite + Pyroscope profiling.”
Alternative formal: “Drove a 4.5× reduction in p99 API latency (850ms → 190ms) for a 14-service platform serving 2.4M MAU, through Go-based hot-path refactoring and continuous Pyroscope profiling.”
Anti-pattern note: Original had no number, no verb, no tool, and “improving” is a corporate-fluff word. Recruiters skip these on first pass.

Pro tip: Run every bullet from every job through this prompt. Expect to spend 2–3 hours doing all 30–50 bullets. That’s the actual job. The rewrite is what makes the resume.

Prompt 12 - STAR bullet rewriter (for management or senior IC roles)

Purpose: Rewrite bullets in STAR format when the role is people-management, EM, or senior IC where “influence” matters as much as the technical work.

Prompt:

You are a US tech resume writer. Rewrite my bullets using the STAR method
(Situation, Task, Action, Result) - adapted for a single-bullet resume format.

For each bullet:
- Compress the Situation + Task into a 5-7 word setup clause.
- Make the Action the main verb-driven phrase.
- Make the Result a quantified, scannable outcome.
- Keep the bullet to 2 lines max (≤28 words).

Inputs: target level [JUNIOR / MID / SENIOR / STAFF / EM]. If SENIOR+, lean into
scope. If EM, lean into people/team outcomes.

VAGUE BULLETS:
<PASTE BULLETS>

Example output (EM bullet):

Original: “Managed a team of engineers.”
STAR rewrite: “Grew backend platform team from 4 to 9 in 18 months; shipped 14 services, raised on-call MTTR from 47m to 12m, retained 100% of team through 2 reorgs.”

Pro tip: STAR is heavier than XYZ. Use STAR for EM, TL, and Staff+ IC roles. Use XYZ for everything else. Mixing both looks unfocused.

Prompt 13 - Quantification booster

Purpose: Take a bullet that has an action but lacks a number, and force a number out of it. Sometimes you have to estimate and mark [VERIFY].

Prompt:

I will paste resume bullets that are missing quantification. For each bullet:

1. If a number is obvious from the bullet, just add it.
2. If a number is plausible but not stated, suggest a reasonable estimate and
   mark it [VERIFY] so I can check.
3. If a number is genuinely unknowable, suggest a proxy metric (e.g., "shipped
   14 services" instead of "scaled platform" because the number of services is
   a proxy for scope).
4. Rewrite the bullet with the number in the most prominent position
   (usually the front of the bullet - recruiters see it first).

Constraints: do not invent numbers I cannot plausibly know. When in doubt, mark
[VERIFY] and explain your reasoning.

BULLETS:
<PASTE BULLETS>

Example output:

Original: “Improved test coverage on the backend.”
Rewrite: “Raised backend test coverage from 38% to 84% (Pytest + Go) across 6 services, cutting prod incidents 31% YoY.”
[VERIFY]: “84%” - confirm exact number; “31% YoY” - confirm by checking P0/P1 incident count in your incident tracker for the year before vs. after.

Pro tip: “If you didn’t measure it, you didn’t do it” is recruiter-think. Even if you have to estimate, having a number beats not having one 9 times out of 10. Always mark [VERIFY] and confirm before submitting.

Prompt 14 - Action verb randomizer (so the resume doesn’t sound robotic)

Purpose: US tech resumes suffer from verb repetition (“Built… Built… Built… Led… Led… Led…”). This prompt suggests a wider vocabulary while keeping it scannable.

Prompt:

Here are 10 resume bullets. I want the verbs varied so the resume doesn't sound
robotic. For each bullet:

1. Identify the current verb.
2. Suggest 2 alternative verbs, each with a 1-line note on the connotation:
   - "Spearheaded" sounds senior, sometimes overused.
   - "Shipped" sounds startup/IC.
   - "Architected" sounds Staff+.
   - "Owned" sounds Senior+ IC.
   - "Drove" sounds cross-functional.
3. Rewrite the bullet with the recommended alternative.

Constraints: do not use "spearheaded", "synergized", "leveraged", "championed",
"spearheaded", "spearheaded" (yes, recruiters see this 3x/week). Stick to verbs
that pass the "would an engineer say this out loud?" test.

BULLETS:
<PASTE BULLETS>

Example output:

Original: “Built a CI/CD pipeline.”
Alternatives: “Shipped” (startup, IC, hands-on) or “Drove the migration to” (cross-functional, leadership).
Rewrite: “Shipped a CI/CD pipeline in 6 weeks, cutting deploy time from 47min to 9min across 22 services.”

Pro tip: Keep a “verb bank” of 20–30 strong verbs: built, shipped, owned, led, drove, designed, scaled, cut, reduced, raised, grew, launched, shipped, architected, refactored, modernized, instrumented, debugged, hardened, mentored, hired, retained. Rotate, don’t repeat.

Prompt 15 - Bullet compression (from paragraph to 1-line bullet)

Purpose: Convert a paragraph-long brag into 2 scannable 1–2 line bullets. This is what happens when a junior’s resume “grew up” but didn’t get edited.

Prompt:

I will paste paragraphs from my resume (or a paragraph I want to use). Convert
each paragraph into 2-3 scannable 1-2 line bullets.

Rules:
- Lead with the strongest number.
- Drop filler words ("responsible for", "tasked with", "helped", "worked on").
- Use the XYZ format.
- Each bullet ≤28 words.
- Bold key numbers if you can (I'll apply markdown in my doc).

PARAGRAPHS:
<PASTE PARAGRAPHS>

Example output (1 paragraph → 2 bullets):

Paragraph (5 sentences): “I was responsible for the migration of our legacy Java backend to Go. This involved working with multiple teams, including the SRE and platform teams. We had to carefully coordinate the cutover, and I helped manage the on-call rotation during the migration. The new system handles 2x the traffic at half the cost. We also reduced p99 latency.”
Bullets:
- “Led end-to-end migration of Java monolith to Go microservices across 14 services, holding p99 latency under 220ms through Black Friday.”
- “Cut infra cost 48% (from $112K/mo to $58K/mo) by right-sizing EC2 + moving cold paths to Lambda, post-migration.”

Pro tip: If a paragraph doesn’t compress, it wasn’t a real accomplishment. That’s a signal to either find the real number or cut it.

Prompt 16 - Bullet ordering within a role (most impactful first)

Purpose: Reorder bullets within a job so the most impressive one is first. Recruiters stop reading after bullet 2 if those don’t hook.

Prompt:

Here are the bullets for one of my roles, in my current order:
<PASTE BULLETS, current order>

Reorder them in the order a US tech recruiter would find most impressive, using
this implicit hierarchy:

1. Scope + business impact (users / $ / GMV).
2. Quantified technical win (latency, cost, reliability, scale).
3. Ownership / leadership (mentored, led, hired, on-call ownership).
4. Collaboration / cross-functional.
5. Day-to-day technical work (code, reviews, refactors).

For each bullet, give me a 1-sentence note on WHY it's at that position.

Then give me the final ordered list.

Example output (for a Senior Backend Engineer):

Final order:
1. “Cut p99 latency 4× ($850ms→$190ms) for 2.4M MAU via Go hot-path rewrite.” ← Why: scope + quantified win.
2. “Owned $40M GMV checkout pipeline end-to-end through 2× Black Friday traffic.” ← Why: scope + ownership.
3. “Mentored 3 junior engineers; 2 promoted to Mid within 14 months.” ← Why: leadership.
4. “Drove cross-team migration from Kafka 2.x to 3.5 with 0 downtime over 6 weeks.” ← Why: cross-functional.
5. “Wrote design docs for service-mesh rollout; 4 docs adopted company-wide.” ← Why: influence.

Pro tip: Bullet 1 and bullet 2 are the only ones most recruiters will read. Make them the two strongest, in that order.

SECTION 4: Skills & keyword prompts (prompts 17–21)

Skills are a minefield in 2026. Put too many and you look like a junior with no depth. Put too few and the ATS rejects you. The right answer: a tight, ranked skills block aligned to the JD, with depth signals. The prompts below handle the tension.

Prompt 17 - Skills block builder (ranked, JD-aligned, no fluff)

Purpose: Build a 4-column skills block (Languages, Frameworks, Infrastructure, Tools/Cloud) with the right level of depth for your target role.

Prompt:

Build a 4-column skills block for my US tech resume. Constraints:

- Column 1: Languages (top 4-6, strongest first).
- Column 2: Frameworks / Libraries (top 4-6, strongest first).
- Column 3: Infrastructure / Data (DBs, queues, cache, orchestration, etc.).
- Column 4: Cloud / DevOps / Observability (AWS/GCP services, Terraform, CI/CD,
  monitoring tools).

Rules:
- Do NOT list "Microsoft Office", "Git", or other table-stakes that pad the
  resume (everyone in 2026 knows Git).
- Do NOT list 30+ tools. Aim for 18-25 total across all 4 columns.
- Order by depth: tools you have 3+ years of production experience with go first.
- Mark tools that are "production-grade, deep" vs. "familiar, used on side projects"
  with a single asterisk (*) next to the latter.
- If a tool from the JD is missing from your real skill set, do NOT add it
  (that's lying). Instead, suggest a "familiar with X" or "exploring X" section
  if you genuinely have exposure.

Inputs:
- Target role: [TITLE] at [COMPANY TYPE]
- Target JD:
  <PASTE JD>
- My real skill set (be honest):
  <LIST YOUR REAL SKILLS>

Example output:

Languages	Frameworks	Infrastructure	Cloud / DevOps
Go (5y)	gRPC · Kafka Streams	PostgreSQL · Redis · Kafka · K8s	AWS (EKS, RDS, S3, Lambda) · Terraform · Datadog · GitHub Actions
Python (4y)	Gin · Echo	ClickHouse · Snowflake*	GCP (GKE, BigQuery)* · ArgoCD
TypeScript (3y)	React (basic)	Temporal*	Prometheus · Grafana · OpenTelemetry
SQL (8y)

* = familiar, not deep.

Pro tip: Don’t include “Docker” - every US tech resume in 2026 has it, and it pads. Do include “Kubernetes (production, multi-tenant)” - the “production” qualifier is the depth signal.

Prompt 18 - JD keyword injector (the right way)

Purpose: Take the keywords from prompt 1 and inject them into your resume naturally - without keyword stuffing.

Prompt:

I will paste:
- The MUST-HAVE and NICE-TO-HAVE keyword list from a JD (output of Prompt 1).
- My current resume.

Your job: for each must-have keyword, tell me:
1. Is it ALREADY present in my resume? Quote the line and section.
2. If not, where SHOULD it go? Give me the exact section + a sample sentence
   that uses the keyword in a real, honest context (not stuffed).
3. If it's not present and I have no real experience with it, FLAG it as
   "do not fake" and suggest an honest framing ("learning", "familiar with",
   "exploring").

Do not just sprinkle keywords. Tell me where they belong in the *story* of my
resume.

KEYWORDS:
<PASTE KEYWORDS>

RESUME:
<PASTE RESUME>

Example output (excerpt):

“Kafka” - present in Skills, absent in bullets. Add to first bullet of Acme role: “Owned 3 Kafka-based event pipelines processing 14M events/day.”
“gRPC” - not present. Flag: “Do not fake. If you’ve never used gRPC in production, do not claim it. Suggest: add a side project using gRPC and put it in Projects, not in skills.”
“PCI-DSS” - not a tool, it’s a compliance framework. Add a one-liner under Acme: “Operated within PCI-DSS Level 1 environment; passed 2 audits with 0 critical findings.”

Pro tip: Keyword match scores on Jobscan over 85% usually mean you’re stuffing. Aim for 70–85% match. Stuffing gets rejected by human reviewers.

Prompt 19 - “AI/LLM-aware” resume add-ons

Purpose: Most 2026 US tech job descriptions mention AI tooling, RAG, vector DBs, evals, or LLM inference. This prompt adds honest AI signals to your resume.

Prompt:

I am a [BACKEND / FRONTEND / FULLSTACK / ML / PLATFORM] engineer applying to
US tech roles in 2026. Most JDs now mention "AI tooling", "LLM integration",
"RAG", "evals", or "vector DB". 

I do NOT have production LLM experience, but I do have:
<LIST HONEST AI-RELATED EXPERIENCE - e.g., "I shipped a side project using
OpenAI API and pgvector", "I took DeepLearning.AI's short course",
"I contributed to an open-source LLM eval library">

Generate 3-5 resume-ready lines I can add (either to a "Projects" section or
as 1 bullet per relevant job) that:
1. Use the exact vocabulary the JDs use (RAG, evals, vector search, prompt
   engineering, embeddings, LLM inference, etc.).
2. Are 100% honest about the depth (use "built", "explored", "prototyped",
   "shipped in side project" - never "production LLM" if it wasn't production).
3. Show the engineering around the AI (latency, cost, observability, evals) -
   not just "I called OpenAI".

Output as 5 numbered lines, each ≤28 words.

Example output (5 lines):

“Shipped internal Q&A bot using RAG over 240 internal Confluence pages; pgvector + OpenAI embeddings, 320ms p95.”
“Built eval harness (Python + pytest) for LLM-output regression; 14 evals across 2 prompt versions.”
“Prototyped a vector-search feature for support docs; cut average search time 41% in user test (n=24).”
“Contributed 3 PRs to OSS LLM eval library promptfoo; one merged to main in v2.4.”
“Took Anthropic’s ‘Claude for Engineers’ and DeepLearning.AI’s ‘Prompt Engineering for Developers’ (certificates, 2025).”

Pro tip: Honesty matters more than volume. One shipped RAG project beats 5 buzzword bullets that don’t survive a technical screen.

Prompt 20 - “Tools I’ve actually used” depth-checker

Purpose: Strip out resume padding. If you used a tool once, you shouldn’t list it as a top skill. This prompt audits the skills block for honesty.

Prompt:

Audit my Skills block for honesty. For each tool listed, classify it as:

A) "Production-grade" - 2+ years in production, can speak fluently in an
   interview about internals, failure modes, scaling, and trade-offs.
B) "Working knowledge" - 6mo-2y, can build things but not deep internals.
C) "Familiar" - <6mo, used in side projects, tutorials, or one-off scripts.
D) "Remove" - listed but I've never actually used it (resume padding).

For each, recommend:
- Keep at current prominence (A)
- Demote to a separate "Familiar with:" sub-section (B, C)
- Remove (D)

Be strict. Recruiters in 2026 catch padding in 5 minutes.

MY SKILLS BLOCK:
<PASTE SKILLS BLOCK>

Example output (excerpt):

“Go (5y)” → A - keep at top.
“Rust (3 side-project weekends)” → C - move to “Familiar with: Rust.”
“Kubernetes” → A - keep, but add “production, multi-tenant” qualifier.
“Spark” → D - remove unless you can whiteboard a Spark shuffle inside-out.
“Solidity” → B/C - demote.

Pro tip: The “Familiar with” sub-section is a US tech resume convention. It tells the recruiter “I won’t pretend to be deep, but I’m not afraid of it.” Use it honestly.

Prompt 21 - Soft skills → hard signals

Purpose: US tech resumes suffer from soft-skill padding (“team player”, “good communicator”). This prompt converts soft claims into hard signals.

Prompt:

Audit my resume for soft-skill padding. For each soft-skill word/phrase
("team player", "good communicator", "leadership", "mentored", "cross-functional",
"self-starter", "passionate", etc.):

1. Tell me if it's backed by a HARD signal in the resume (e.g., "mentored"
   + a quantified "3 juniors promoted to Mid in 14 months" = backed; just
   "mentored" alone = padding).
2. If it's padding, suggest a concrete, quantified replacement bullet that
   demonstrates the same soft skill via a hard metric.
3. If a soft skill is genuinely important for the target role but
   not demonstrated, suggest ONE project or activity I can take on in the
   next 4-6 weeks to make the claim real.

Target role: [TITLE]

MY RESUME:
<PASTE RESUME>

Example output:

“Cross-functional collaboration” - currently padding (no number). Replace with: “Partnered with PM, Design, and SRE to ship 14 services across 2 orgs in 6 months; zero re-orgs required.”
“Leadership” - currently “Led team of X.” Strengthen: “Led team of 7 through 2 reorgs; retained 100% of team; raised on-call MTTR 4×.”
“Strong communicator” - add: “Authored 12 design docs adopted company-wide; ran monthly eng-all-hands for 18 months.”

Pro tip: Soft skills are tested in interviews, not read from resumes. Use the resume to plant the proof - a number, a project, a scope - that the interviewer will pick up and ask about.

SECTION 5: Projects & side-gig prompts (prompts 22–25)

Side projects and OSS contributions are how US tech resumes get unstuck for senior candidates who lack obvious “scale” stories at work. A well-placed 2-line project bullet can do what 3 lines of work history can’t. The prompts below turn your side work into resume gold.

Prompt 22 - Side project → resume bullet

Purpose: Convert a side project (GitHub repo, weekend hack, open-source contrib) into a 1–2 line resume bullet that reads like a work accomplishment.

Prompt:

I will paste a description of a side project or open-source contribution. Convert
it into 1-2 resume bullets using the XYZ format. Constraints:

- Lead with a number (stars, downloads, users, latency, etc.) if you have one.
- Use the same verb density and voice as a work bullet.
- Mention the stack in a parenthesized aside, not as the headline.
- If the project is too small to be impressive, suggest what to ADD to it
  (in 2-4 weeks) to make it resume-worthy.

PROJECT:
<PASTE DESCRIPTION OR README LINK>

Example output (1 project, 2 bullets):

Project: A CLI tool written in Go that ingests CSV and pushes to Postgres.
Bullets:
- “Built csv2pg (Go, 2.4k GitHub stars, 12 contributors): typed CSV → Postgres loader with schema inference, 8× faster than COPY for <1M rows.”
- “Maintainer; ~40 PRs reviewed, 3 minor releases, 0 CVEs; project featured in Go Weekly #231.”

Pro tip: A 2-line bullet for a 1k-star project is more resume-worthy than a 2-line bullet for an internal tool that “improved performance.” Stars are a public proxy for impact.

Prompt 23 - OSS contribution → “open-source maintainer” line

Purpose: If you contribute to OSS, frame it correctly on the resume. Most engineers undersell this.

Prompt:

I will paste a list of my open-source contributions. Convert them into 1-3
resume lines that demonstrate technical judgment, sustained contribution, and
(relevant) collaboration. The format should be:

"<Project> (<lang>) - <your specific contribution>. <Stars / downloads / users
metric if available>."

If I am a maintainer of a project, say so explicitly ("Maintainer since
<year>"). If I am a regular contributor, use "Contributor" + number of
merged PRs.

Avoid vague lines like "Active in open source." Always name the project, the
contribution, and a number.

OSS LIST:
<PASTE LIST>

Example output:

“Maintainer, pgcat (Rust, 6.2k stars) - joined as contributor in 2023, took over release mgmt in 2024; shipped v1.2 + v1.3 with 2 other maintainers.”
“Contributor, kubernetes/ingress-nginx (Go) - 7 merged PRs across 2 years; one refactor adopted upstream in v1.10.”
“Author, engineer-resume-prompts repo (this guide’s ancestor) - 1.4k stars, 12 contributors, 38 releases.”

Pro tip: If you have 0 OSS, you can build 1 in 4–6 weeks that lands on your resume. Pick a tool you already use, find a small bug, send a PR, then iterate. The first PR is the hardest.

Prompt 24 - “Career break” project reframe

Purpose: Career breaks (caregiving, layoff, health, study) don’t have to be resume holes. This prompt reframes what you did during the break.

Prompt:

I had a career break from [START] to [END] for [REASON - e.g., caregiving, layoff,
health, study]. During this time I:

<LIST WHAT YOU ACTUALLY DID - even small things>

Convert this into 1-3 resume lines that:
1. Use the same verb density and voice as a work bullet.
2. Are 100% honest (no faking of employment).
3. Demonstrate engineering relevance (shipping, learning, building, contributing).
4. Optionally suggest framing under a "Selected Projects" or "Independent
   Work" section so it's clearly not a job.

If the break is genuinely empty, suggest 1-2 small, doable projects
(2-6 weeks each) that would make the break productive on paper.

Example output (caregiving break, 8 months):

Section header: “Selected Projects (2024–2025)”
“Built claudemd (Go, 600 stars): Claude-code-friendly markdown linter, used by 3 friends’ teams.”
“Completed AWS Solutions Architect Associate + GCP Cloud Engineer certs (2024).”
“Contributed 4 PRs to pgx (Go Postgres driver); 3 merged.”

Pro tip: Honesty + small wins beats a fabricated contract. Recruiters in 2026 are more flexible about career breaks than they were in 2019, especially when the break is filled with verifiable activity.

Prompt 25 - “Contract / freelance” framing

Purpose: Contract work and freelancing are common for senior engineers between full-time roles. The framing matters - done wrong, it looks like a job-hopper.

Prompt:

I have done [N] months of contract / freelance work in [YEAR]. I will paste the
list. Convert it into 1-3 resume lines that:

1. Group the contracts under a single "Independent Consulting" or "Contract
   Engagements" header if they were short.
2. Show client types (startups, fintech, etc.) and scope (services shipped,
   languages used) without violating NDAs (no client names unless I'm sure).
3. Demonstrate the same "scope + impact" voice as a full-time role.
4. Avoid looking like job-hopping: if I had 5 contracts in 12 months, group
   them; don't list all 5 separately.

CONTRACT LIST:
<PASTE LIST>

Example output (4 contracts, 10 months):

“Independent Backend Consultant (Jan–Oct 2025) - Go, Postgres, AWS. Shipped payment integrations for 4 US-based startups; 2 of those startups raised Series A in 2025.”

Pro tip: NDAs matter. Don’t name clients unless you have explicit permission. “Two Series A startups” is honest, scoped, and impressive.

SECTION 6: Tailoring & ATS prompts (prompts 26–27)

Tailoring is the last 20% of work that makes the resume land. The first 80% is the master resume; the last 20% is per-job. The prompts below are the AI-aware, LLM-aware, ATS-aware final step.

Prompt 26 - JD-targeted full-resume rewrite

Purpose: Take your master resume and the JD, and produce a tailored version. This is the highest-leverage prompt in the library.

Prompt:

You are a US tech resume strategist in 2026. You understand:
- ATS parsers (Sovren, RChilli, Affinda, iCIMS, Workday)
- LLM-based resume reviewers (Simplify, Resume Worded, huntr)
- The XYZ formula (Laszlo Bock, ex-Google SVP People, author of Work Rules!)
- The "Top-of-Funnel Recruiter Screen" (6 seconds) used by Greenhouse pipelines.

Inputs:
- My master resume:
  <PASTE>
- The target JD:
  <PASTE>
- Target company: <NAME>
- Target level: <TITLE>

Your job: produce a tailored version of my resume that:
1. Reorders bullets within each role so the most JD-relevant ones are first.
2. Rewrites 2-4 bullets per role to mirror the JD's vocabulary (without lying
   or stuffing).
3. Adjusts the skills block to lead with the JD's most-emphasized tools.
4. Adjusts the headline to include 1-2 JD-specific keywords.
5. Keeps the resume to 1 page (or 1.5 if 7+ years experience).
6. Flags any lies-to-avoid - places where the temptation to add a keyword would
   require faking experience.

Output:
- The full tailored resume (markdown).
- A short "what changed and why" diff at the end.
- A keyword-match estimate vs the JD (rough %).

Example output (excerpt of “what changed and why”):

Reordered Acme bullets: latency bullet moved from #3 to #1 (matches JD’s “performance at scale” emphasis).
Rewrote 2nd Acme bullet: added “Kafka” and “14M events/day” to match JD’s “high-throughput event pipelines” requirement.
Skills block: moved “Kafka” to top of Infrastructure column (was 3rd).
Headline: added “high-throughput” to match JD’s vocabulary.
Keyword match: ~78% (target 70–85%).

Pro tip: Run this prompt once per application. Save the output as tailored_<company>_<role>.md. After 10 applications, you’ll have 10 variants and a strong sense of which bullet patterns work.

Prompt 27 - AI/LLM-aware final polish

Purpose: The final 5% - making sure the resume is friendly to both ATS and the LLM-based review tools (Simplify, Resume Worded AI, huntr) that 40%+ of US tech recruiters now use as a second pass.

Prompt:

I have a final, tailored version of my US tech software engineer resume. I will
paste it below. Do a final-pass polish for the 2026 hiring environment:

1. Check that the resume is fully ATS-parseable:
   - Single-column layout, no tables for layout (only for the skills block).
   - Standard section names: "Experience", "Education", "Skills", "Projects".
   - No headers/footers, no images, no icons, no columns.
   - Plain fonts (no ligatures).
2. Check that the resume is LLM-reviewer-friendly:
   - Clear role/company/date at the top of each job.
   - Each bullet has a number, a verb, and a tool.
   - "Skills" block is a real, scannable list.
3. Check for AI-tell phrases that are instant red flags for both ATS and
   human reviewers in 2026:
   - "delve", "tapestry", "in the ever-evolving landscape of", "moreover",
     "furthermore", "it's important to note", "navigate the complexities",
     "spearheaded", "synergize", "leverage" (as a verb), "cutting-edge",
     "passionate about", "rockstar", "ninja", "guru".
   - If any are present, rewrite the sentence.
4. Check that the first 100 words contain the target job title + top 2 stack
   keywords (this is the area most LLM-reviewers weight highest).
5. Check the resume is ≤ 1 page (≤ 1.5 pages if 7+ years experience).

RESUME:
<PASTE>

Output:
- The polished resume.
- A 10-line "polish report" with what you changed.

Example output (polish report):

ATS: clean (single-column, standard sections, no images).
LLM-friendly: ✓ each bullet has a number + verb + tool.
AI-tell scan: removed “leveraged” from bullet 3 (rewrote as “used”). Removed “passionate about” from summary.
First 100 words: contains “Senior Backend Engineer” + “Go” + “Postgres” + “Kafka” - ✓
Length: 1.5 pages (8 years experience) - ✓.

Pro tip: Re-run this prompt on your master resume every 3 months. AI-tell phrases evolve; “spearheaded” was fine in 2018 and cringe in 2026.

Comparison TABLE: prompt categories vs. resume section vs. output

Here’s the master map. The table is what to use when you know what part of your resume is broken but not which prompt to grab.

#	Prompt	Category	Resume section it fixes	Typical output
1	JD keyword extractor	Audit	Master doc, drives everything else	7-section keyword bucket
2	Resume vs JD gap analyzer	Audit	Whole resume	4-section gap report
3	Recruiter-screen sim	Audit	Headline + bullets 1-2	6-second read critique
4	Seniority calibration	Audit	Whole resume	5 level-tuned bullet rewrites
5	Reverse chronological check	Audit	Order, dates, gaps	6-section sanity audit
6	Headline generator	Headline	Top 1-3 lines	5 headline variants
7	Summary paragraph	Headline	”Summary” block	3-4 sentence summary
8	One-liner tagline	Headline	LinkedIn / GitHub / cold email	3 length variants
9	Title calibration	Headline	Title line	3 title alternatives
10	30-second pitch	Headline	Cover letter, recruiter screen	75-word pitch + 3 derivations
11	XYZ bullet rewriter	Bullets	Job experience bullets	Quantified XYZ bullets
12	STAR bullet rewriter	Bullets	EM / senior IC bullets	STAR-formatted bullets
13	Quantification booster	Bullets	Vague bullets	Bullets with [VERIFY] numbers
14	Action verb randomizer	Bullets	Robotic verb repetition	Varied verb vocabulary
15	Bullet compression	Bullets	Paragraphs of brag	1-2 line scannable bullets
16	Bullet ordering	Bullets	Order within each role	Reordered, impact-first list
17	Skills block builder	Skills	”Skills” section	4-column ranked block
18	JD keyword injector	Skills	Whole resume	Where each keyword belongs
19	AI/LLM-aware add-ons	Skills	Projects / bullets	5 honest AI signal lines
20	Tools depth-checker	Skills	Skills block honesty	A/B/C/D classification
21	Soft skills → hard signals	Skills	Whole resume	Padded claims → quantified
22	Side project → bullet	Projects	Projects / side gigs	1-2 line project bullets
23	OSS contribution	Projects	Open-source line	1-3 maintainer/contributor lines
24	Career break reframe	Projects	Gap years	1-3 productive break lines
25	Contract / freelance	Projects	Contract roles	Grouped consulting line
26	JD-targeted full rewrite	Tailoring	Whole resume	Full tailored version
27	AI/LLM-aware final polish	Tailoring	Final pass	Polished resume + 10-line report

A 14-day “first 3 calls” sprint

This is the part I wish someone had given me 5 years ago. If you’re a US-based or US-targeting software engineer with a current resume, here’s the 14-day sprint that gets you 3 recruiter calls in 2 weeks. The math: ~250 targeted applications per role in a normal job search; this sprint targets ~30 high-fit roles with tailored resumes, and aims for 3 recruiter calls (~10% callback rate on well-tailored applications).

Days 1–2: Audit and master resume.

Run Prompt 1 + Prompt 2 against 3 of your target JDs.
Build a single master resume using Prompts 6, 9, 11, 15, 16, 17.
Run Prompt 27 (final polish).

Days 3–4: Target list.

Make a spreadsheet of 30 US tech roles: 10 in your strongest stack, 10 in adjacent stack, 10 stretch roles.
For each: paste the JD, run Prompt 1, save the output as jd_<company>_<role>.md.

Days 5–10: 30 tailored resumes.

5 resumes/day (about 25–30 min each).
For each: run Prompt 26 (full rewrite) using the master resume + JD.
Save as tailored_<company>_<role>.md. Apply same day.

Days 11–12: Pipeline and follow-up.

LinkedIn: update headline (Prompt 8, v1), About (Prompt 8, v3), and 3 most recent “Featured” links.
Cold email 10 hiring managers using the prompt from Prompt 10.
Apply to the Greenhouse / Lever / Ashby job posts directly (not just LinkedIn).

Days 13–14: Iterate and repeat.

Expect 2–6 recruiter screens in week 2 from the first batch.
Update resume based on what JDs are actually asking for.
Apply to 10 more.

After 30 days of this sprint, expect 8–15 recruiter screens and 2–4 onsites. That’s the baseline. The prompts in this library are the workhorse. The sprint is the discipline.

Common mistakes to avoid

These are the mistakes I see on 80% of resumes I review. Each is fixable with a prompt in this library.

Mistake 1: “Responsible for” and “tasked with.” These are passive and recruiter-think signals that you did the bare minimum. Replace with action verbs (Prompt 14) and XYZ format (Prompt 11). “Responsible for backend services” → “Owned 14 backend services, cutting p99 4×.”
Mistake 2: No numbers. Recruiters trust numbers. If you don’t have them, get them (Prompt 13) or proxy them (number of services, users, lines of code, test coverage). “Worked on performance” → “Cut p99 4×.”
Mistake 3: Two-column layout with a sidebar. It looks pretty in Google Docs. It parses into garbage in 75% of ATS systems. Use single column.
Mistake 4: Listing 30+ tools in the skills block. Padding. Most “skills” you’ve used twice in 5 years. Audit with Prompt 20.
Mistake 5: Buzzwords. “Passionate”, “rockstar”, “guru”, “ninja”, “spearheaded”, “synergize”, “leverage”, “delve”, “tapestry”, “in the ever-evolving landscape.” All AI-tells or corporate tells. Remove all of them (Prompt 27 catches these).
Mistake 6: Not tailoring per JD. One resume for 250 applications = 250 rejections. 20–30 min of tailoring per role = 10× better callback rate.
Mistake 7: Burying the headline. If your headline is “Software Engineer” and your first bullet is “Wrote internal scripts,” you’ve already lost. The headline must scream level + stack + impact (Prompts 6, 9).
Mistake 8: Lying about skills. You will get caught in the technical screen. If you’ve never used Kafka in production, don’t list it as a top skill. Use the “Familiar with” sub-section (Prompt 20).
Mistake 9: Ignoring the LLM-aware layer. 40%+ of US tech recruiters in 2026 use AI tools (Simplify, Resume Worded, huntr) as a second-pass review. Your resume must be friendly to both ATS and LLM parsers (Prompt 27).
Mistake 10: Not having a 30-second pitch ready. Recruiter screens start with “tell me about yourself.” If you can’t say it in 30 seconds (Prompt 10), you’ll ramble. Rehearse.

Final word

Most engineer resumes fail not because the engineer is weak, but because the resume is generic, untailored, and unquantified. The 27 ChatGPT prompts in this library are how you fix that. The work is real - expect 6–10 hours of editing per application cycle. The payoff is real - 3 recruiter calls in 14 days, then 2–4 onsites in 30 days, then a job.

Three things to remember:

The JD is the source of truth. Run Prompt 1 on every job. Don’t apply without a target keyword list.
The XYZ formula is your best friend. Every bullet is “Accomplished X, as measured by Y, by doing Z.” No exceptions.
The resume is a living document. Run Prompt 27 (final polish) every 3 months. AI-tells evolve. Your target roles evolve. The resume should too.

Now go run the prompts. Land the calls. Ship the resume.

Reader disclosure & educational-purpose notice

This page is published by SuperFreshAI for general informational and educational purposes only. By reading it, you agree to the points below.

Editorial independence. All reviews, guides, and recommendations are written by our editorial team based on hands-on use. Some links on this site are affiliate links, and some articles are produced as partner content — both are always clearly labeled. Our editorial conclusions are never shaped by partners or affiliates.
Not professional advice. Nothing on this page constitutes legal, financial, medical, tax, or other professional advice. AI tools, pricing, and capabilities change quickly — always verify current information with the tool's official documentation before making a decision.
Educational purpose only. The content here is intended to help you learn about AI tools and workflows. It is not a guarantee of results, performance, fitness for a particular purpose, or suitability for your specific situation. Your results may vary.
No warranties. The site and its content are provided on an "as is" and "as available" basis. We make no warranties, express or implied, about accuracy, completeness, reliability, or availability. See our Terms and Privacy for the full legal terms.
Your responsibility. You are responsible for how you use the information on this page, including any decisions you make based on it. Always do your own research and consult a qualified professional when appropriate.
Affiliate & partner disclosure. When you click certain outbound links, we may earn a commission at no extra cost to you. When a piece of content is produced as partner content, it is labeled at the top of the page. See our Editorial Policy for the full standards we follow.

By continuing to read, you acknowledge that you have read and understood this notice.

27 ChatGPT prompts for software engineers to rewrite resumes for US tech roles

Why 75% of resumes die in the ATS (with 2026 stat)

The 4-stage engineer-resume anatomy

SECTION 1: Audit & target prompts (prompts 1–5)

Prompt 1 - JD keyword extractor

Prompt 2 - Resume vs JD gap analyzer

Prompt 3 - Recruiter-screen sim (“Top-of-Funnel Recruiter Screen” by Greenhouse)

Prompt 4 - Seniority calibration prompt

Prompt 5 - “Reverse chronological” sanity check

SECTION 2: Summary & headline prompts (prompts 6–10)

Prompt 6 - Headline generator from scratch

Prompt 7 - Summary paragraph (optional, but powerful for senior+)

Prompt 8 - “One-liner tagline” for GitHub, LinkedIn, and cold email

Prompt 9 - Title calibration prompt

Prompt 10 - “Why me” 30-second pitch (for cover letters and recruiter calls)

SECTION 3: Bullet & impact prompts (prompts 11–16)

Prompt 11 - XYZ bullet rewriter (the workhorse)

Prompt 12 - STAR bullet rewriter (for management or senior IC roles)

Prompt 13 - Quantification booster

Prompt 14 - Action verb randomizer (so the resume doesn’t sound robotic)

Prompt 15 - Bullet compression (from paragraph to 1-line bullet)

Prompt 16 - Bullet ordering within a role (most impactful first)

SECTION 4: Skills & keyword prompts (prompts 17–21)

Prompt 17 - Skills block builder (ranked, JD-aligned, no fluff)

Prompt 18 - JD keyword injector (the right way)

Prompt 19 - “AI/LLM-aware” resume add-ons

Prompt 20 - “Tools I’ve actually used” depth-checker

Prompt 21 - Soft skills → hard signals

SECTION 5: Projects & side-gig prompts (prompts 22–25)

Prompt 22 - Side project → resume bullet

Prompt 23 - OSS contribution → “open-source maintainer” line

Prompt 24 - “Career break” project reframe

Prompt 25 - “Contract / freelance” framing

SECTION 6: Tailoring & ATS prompts (prompts 26–27)

Prompt 26 - JD-targeted full-resume rewrite

Prompt 27 - AI/LLM-aware final polish

Comparison TABLE: prompt categories vs. resume section vs. output

People Also Ask FAQ (8–10 questions with concise answer-first responses)

1. What is the XYZ resume formula and why do US tech recruiters love it?

2. How long should a US software engineer resume be in 2026?

3. Should I put a “Summary” section on my US tech resume?

4. How does the ATS (Applicant Tracking System) actually parse my resume?

5. What keywords do US tech recruiters actually look for in 2026?

6. How is the US tech job market for software engineers in 2026?

7. Should I tailor my resume for every US tech job application?

8. What’s the difference between a US tech resume and a European one?

9. What’s a “Top-of-Funnel Recruiter Screen”?

10. Should I use ChatGPT to write my whole resume?

A 14-day “first 3 calls” sprint

Common mistakes to avoid

Final word

SuperFresh AI

43 ChatGPT prompts for non-native English speakers to polish interview answers

41 ChatGPT prompts for SaaS founders in San Francisco to map local partnership opportunities

How to Detect AI-Generated Content

What Is the Best AI Tool for Writing?

AI Newsletter Writing Guide

Get practical AI insights in your inbox