Only those who can write resumes know how to read resumes, and only those who can read resumes know how to write resumes. The same set of skills, used in a different direction.
Mode Selection
| Mode | Input | What It Does |
|---|---|---|
| A. Resume + JD | Resume + JD | Diagnose → write custom.json → render application version HTML |
| B. Resume Only | Resume | Parse into master.json → infer target JD → rewriting suggestions |
| C. JD Only | JD | Infer the ideal resume profile → rewrite the JD or generate resume direction |
| D. Create from Scratch | Position + Years of Experience | Q&A collection → build master.json |
Industry Differences (resume writing focuses differ)
| Industry | Resume Focus | Common Pitfalls |
|---|---|---|
| Technology/R&D | Tech stack list + quantified results + project depth | Piling up skill keywords without results, projects without numbers |
| Product/Operations | Data metrics + user insights + business loop closure | Only writing actions without results, no user scale |
| Design/Creative | Portfolio entry + design thinking + project impact | Too much text on the resume, missing portfolio link |
| Finance/Accounting | Numerical sensitivity + compliance awareness + tool proficiency | No quantified performance, no certificates or qualifications listed |
| Sales/Marketing | Performance numbers + customer cases + channel capabilities | Only 'responsible for sales' without specific numbers |
| Management Roles | Team size + results + decision-making cases | Only writing how many people were led, not what was achieved |
| Administration/Functional | Process optimization + efficiency improvement + cross-department collaboration | Bland experience without quantification, no specific cases |
Group Differences (resume presentation angles differ)
| Group | Resume Strategy |
|---|---|
| New Graduates | Focus on projects/internships/competitions, highlight learning ability and potential; even without experience, have work samples |
| Career Changers | 'Translate' experience from the old industry into the target industry's language, highlight transferable skills |
| Older Workers | Highlight compounding experience and judgment, downplay years-of-experience numbers, strengthen results |
| Remote/Freelance | Delivery cases + time management + evidence of self-motivation |
| Returnees/Foreign Enterprises | Chinese-English bilingual resume, highlight cross-cultural communication and global projects |
| Re-employment | Fill gaps with learning/projects/family management, highlight evidence of skills staying fresh |
Portraits of Two Types of Screeners
HR initial screening (first gate): Batch scanning, 5-15 seconds per resume. Criteria: keyword matching + basic qualifications met. Eliminate: missing keywords, messy formatting, no visible substance.
Hiring manager (second gate): Interested, reads carefully for 5-10 minutes. Criteria: Does what they've done match the role? Is the logic clear? Eliminate: only responsibilities without results, experience order doesn't correspond to job requirements.
Job seeker's perspective: resume diagnosis
10-second test
Show your resume to a stranger for 10 seconds, ask: What has this person done? What are they good at? Why should we hire them?Can't answer in 10 seconds → resume fails.
Three resume questions
- Does the first screen have "why should we hire you"? Not self-introduction, but value proposition.
- Does each experience have "what was done + what was the result"? Not a job description, but an achievement showcase.
- Can the match with the target role be seen at a glance?
Revision rules
- Delete all sentences starting with "responsible for XX", change to "did XX, result was XX"
- Numbers > adjectives ("greatly improved" → "improved by 40%")
- Who was affected? How many people? How much efficiency improved? How much cost reduced? Direct numbers > ratios > scale descriptions
JD decoding (understand the deeper information)
A JD has two layers:Surface layer(the written responsibilities and requirements) anddeep layer(why this role exists, what stage the team is at, what problem hiring solves). Preparing only for the surface layer makes you "qualified"; understanding the deep layer prepares you to be "the most suitable person".
Four-step method (full version see references/jd-decoding.md）：
- Judge role maturity: Vague responsibilities = zero to one (need self-drive); detailed responsibilities = scaling (need execution); wants both A and B = understaffed (need generalist)
- Extract real requirements: hard thresholds (fail directly if unmet) / core requirements (first three) / bonus points
- Identify implicit requirements: "able to withstand pressure" = frequent overtime; technical role "communication skills" = cross-team collaboration; "has taste" = judgment standards matter more than a usage checklist
- Judge match: All hard thresholds met? Core ≥70%? Bonus ≥1? → Decide apply/revise/skip
Bidirectional rewriting
Mode A: Resume + JD → rewrite resume
- Extract JD core elements (hard thresholds/core competencies/bonus points)
- Diagnose paragraph by paragraph: which experience isn't quantified? Which keyword is missing?
- Output the complete rewritten version(original → revision comparison, no abstract principles)
- If a master version exists/can be built: write the revision targets into
custom.json(overrides + exclude + order), then runrender_resume.pyto produce the application HTML
Mode B: Resume only → infer JD
- Parse/complete master version from resume
master.json(fields seeassets/master-template.json） - Infer target role type from resume (technical/business/management/content/functional)
- Infer screening criteria by role type
- Output revision suggestions + cold-start diagnosis; when there is a clear target JD, switch to Mode A to derive a version
Mode C: JD only → infer ideal resume
- Reverse-engineer the ideal candidate profile from the JD
- Provide a checklist of the elements a resume should have
- Output the direction for rewriting the JD or resume; when the user has experience material, switch to Mode D to build the master version
Mandatory principles: For each diagnosis, provide an "original text → revision" comparison; hard flaws (education/years of experience) are mentioned first, without avoidance; bonus-point suggestions come after the hard flaws.
Resume generation
Create from scratch (Mode D)
Collect information step by step according to the 9 modules (ask only 1-2 questions at a time, skippable): Basic information → Education background → Supplementary materials → Work experience (reverse chronological) → Project experience → Internship experience → Competition awards → Professional skills → Other
Local code import: When the user has project code, read the key code files, analyze the technical contributions, and distill them into contribution descriptions usable for the resume.
Resume master version (starting point of the output layer)
The endpoint of Mode D is themaster version master.json, not a one-off resume text. The master version is the single source of truth, fully retaining all experience (only additions, no deletions).
- Master version field structure →
assets/master-template.json - Establishment and maintenance process →
references/master-versioning.md(parse an old resume / interview for real experience, two paths) - When parsing from an existing resume: transcribe only, do not judge; if quantitative numbers are missing → interview the user to supplement them; if they cannot be supplemented, retain them as-is and mark them as "to be quantified"
Career matching recommendations
After the resume is generated, recommend 3-5 positions based on the user profile (match level/reasons/market demand/career path).
Targeted application optimization (output layer: derived versions)
- Break down the JD: hard requirements / soft requirements / keywords (ATS basis)
- Match self-check：
python3 scripts/jd_resume_match.py jd.txt resume.txt(hard threshold hits/skill coverage/quantitative indicators/match score) - Write custom.json：
order(section ordering) /exclude(trim irrelevant experience) /overrides(rewrite summary and skills according to the JD) - Render standalone HTML：
python3 scripts/render_resume.py master/master.json --custom versions/<日期_公司_岗位>/custom.json --out versions/<日期_公司_岗位>/resume.html- Produce
resume.html(standalone single file, open in browser → print to PDF) +resume.txt(ATS plain text) + print page count estimate
- Produce
- Version archiving: application versions go in
versions/YYYY-MM-DD_公司_岗位/, submitted versions are immutable; modifying the master version does not touch old versions - Targeted adjustments: naturally incorporate keywords, emphasize soft requirements, delete irrelevant experience (use exclude, without touching the master version)
For the complete conventions (workspace directory structure, version naming, maintenance operations, taboos), see
references/master-versioning.md. The master version only grows, never shrinks; customization only happens at the version layer—this is the essential difference between this skill and "one-off resume rewriting."
ATS hidden barriers
Naturally incorporate keywords without stuffing ("Used Python to develop a data processing pipeline, improving efficiency by 60%" > "Proficient in Python"); use standard formatting and avoid tables and images; start with verbs × end with results. For the ATS plain-text self-check, use the rendered output resume.txt。
Employer perspective: JD diagnosis and resume screening
Three JD questions
After reading, does the candidate know what problem the position solves? Are "must-have" and "bonus" separated? Is the salary range stated?
HR-side resources
- JD writing standards →
references/hr-jd-writing.md - Three-layer resume screening method →
references/resume-jd-match.mdrelated chapters
Reference documents (read as needed)
| Document | When to read |
|---|---|
references/jd-decoding.md |
When you need to decode the deeper information in a JD |
references/resume-jd-match.md |
When doing JD↔resume matching and rewriting |
references/resume-optimization.md |
When optimizing resume expression (Summary hook/STAR formula/ATS) |
references/hr-jd-writing.md |
When the employer side writes a JD |
references/master-versioning.md |
When building a master, deriving versions, and maintaining application versions |
assets/master-template.json |
When creating a new master (field structure template) |
assets/resume-template.html |
When you need to adjust the resume layout/print style (the single source of truth for styling) |
scripts/render_resume.py |
When rendering the master → HTML/TXT (python3 scripts/render_resume.py -h） |
Downstream collaboration
| Trigger conditions | Recommended |
|---|---|
| The resume is revised and ready to apply | taxue-career-channel |
| The resume direction is wrong | taxue-career-direction |
| Interview | taxue-career-interview |
DO NOT
- Interview preparation →
taxue-career-interview - Choosing an Offer/salary negotiation →
taxue-career-offer - Creating a new skill from scratch →
skill-creator
Language
- If the user uses Chinese, reply in Chinese; if the user uses English, reply in English
- Chinese replies follow the Chinese Copywriting Style Guide
taxue-career-resume v3.1.0 — Diagnose · Decode · Rewrite · Generate · Optimize · Master to version output*