dennisthiessen/claude-resume-kit
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: rebuild evidence-first application workflow

Browse Source
This commit is contained in:
dennisthiessen
2026-07-27 17:56:15 +02:00
parent c24892f381
commit fe5f24704f
57 changed files with 3815 additions and 3555 deletions
Download Patch File Download Diff File Expand all files Collapse all files
README.md
+59 -137
View File
@@ -1,163 +1,85 @@
# claude-resume-kit
# Evidence-first resume kit
Most AI resume tools work the same way: paste resume + paste JD, get a rewrite. They don't know which of your papers is published vs. under review. They don't know you only ran the simulations, not the experiments. They'll upgrade "contributed to" into "developed" without blinking.
This repository turns verified career evidence into role-specific LaTeX resumes and, when useful, cover letters. It is designed to prevent a common failure mode of AI-assisted applications: making a document sound closer to the job description by silently overstating skills, scope, titles, or outcomes.
This is different. You extract your papers, codebases, and reports once — the system asks structured questions about each one. After that, every new application is just pointing it at a JD. It picks the right achievements, frames them for the audience, enforces accuracy, and generates LaTeX you compile locally.
The workflow separates three questions that should never be confused:
Built for researchers and engineers with lots of source material (papers, code, reports) who apply to many positions across different employer types.
1. **Evidence Fit:** does the candidate actually meet the role, including hard gates?
2. **Document Quality:** does the resume communicate the supported evidence clearly?
3. **Channel Strength:** is the application cold, referred, or supported by a warm contact?
---
A polished resume cannot repair a failed qualification gate. A strong fit can still be hidden by a weak document. The system records both.
## What makes this different
## Source hierarchy
**Knowledge base, not a rewriter.** You extract once. Every application draws from verified source material — not a pasted resume that gets "improved."
**Anti-fabrication by design.** Provenance flags on every achievement (published / under review / internal). Verb discipline rules prevent overclaiming. A corrections log ensures fixed errors don't reappear.
**AI fingerprint avoidance.** Banned-word lists, structural anti-patterns, and a 12-item post-generation scan so output reads as human-written.
**Multi-perspective critique.** Five reader personas (ATS bot through technical reviewer) score your resume across 8 dimensions in a fresh context window.
**LaTeX output, locally compiled.** No data leaves your machine beyond the Claude Code conversation.
---
## Example Output
Here's what the system generates for the included fictional researcher (Dr. Jordan Chen, computational biologist) applying to a tenure-track faculty position:
- [Example Resume (PDF)](resume_builder/examples/example_resume.pdf) — 2-page resume with JD-tailored bullets, skills, and publications
- [Example Cover Letter (PDF)](resume_builder/examples/example_cover_letter.pdf) — 1-page academic cover letter with specific hooks
- [Example Session File](resume_builder/examples/example_session_file.md) — the decision log that produced this output
- [Source .tex files](resume_builder/examples/output/) — the LaTeX source Claude generated
All example data is in `resume_builder/examples/` — extraction, experience file, bundle, config, and session file.
---
## What you actually do
**One-time setup (~10 min per paper):**
1. Drop your papers/reports into `knowledge_base/papers/`
2. Run `/setup-extract` on each — Claude reads it and asks you questions about your contributions and publication status
3. Run `/setup-build-kb` — synthesizes everything into your knowledge base
**Per application (~15-20 min):**
1. Drop the JD into `JDs/`
2. Run `/make-resume JDs/target_job.txt` — approve the bullet plan, get a `.tex` file
3. Run `/make-cl` for a cover letter
4. Run `/critique` for a scored review with specific fixes
Each step uses a **separate Claude Code session** for best quality (fresh context = less bias).
---
## Prerequisites
- **[Claude Code](https://docs.anthropic.com/en/docs/claude-code)** CLI installed and authenticated
- **A LaTeX distribution** for compiling `.tex` to `.pdf` (e.g., [TeX Live](https://tug.org/texlive/), [MacTeX](https://tug.org/mactex/), [MiKTeX](https://miktex.org/))
- **Your research papers** or project documentation ready for extraction
---
## Try it first (5 minutes)
Want to see what it does before extracting your own papers? The repo includes a complete example knowledge base for a fictional researcher:
```bash
git clone https://github.com/ARPeeketi/claude-resume-kit.git
cd claude-resume-kit
claude
/make-resume JDs/example_jd.txt
```text
source documents
-> structured extractions
-> canonical claims registry
-> experience records and role bundles
-> session plan
-> generated resume / optional cover letter
```
This runs the full pipeline — JD analysis, bullet selection, LaTeX generation — using the included example data. No setup required.
`resume_builder/canonical/claims.json` is the highest-authority career source. Generated files under `output/` are never treated as evidence. `historical_outputs.json` records whether an older package is safe to consult, must be revalidated, or must not be reused.
---
## Default application strategy
## Full Setup
- Target Staff/Senior Data Engineering first.
- Use ML Platform/MLOps, data platform, analytics, and semiconductor profiles only where direct evidence covers the actual requirements.
- Treat direct LLM engineering, formal model evaluation, Terraform-heavy SRE, and similar missing required experience as gates rather than keyword opportunities.
- Build application cohorts with roughly 70% core, 20% adjacent, and 10% deliberate stretch roles.
- Add a warm-channel action for core applications.
### 1. Clone and configure
The default document is a two-page International Tech resume for US-tech/FAANG-style roles in Europe. A Swiss/DACH policy overlay is available for employers that expect local conventions. Cover letters are conditional, not automatic.
```bash
git clone https://github.com/ARPeeketi/claude-resume-kit.git
cd claude-resume-kit
## Workflow
### Add evidence
1. Put employment records, project material, papers, or notes under `knowledge_base/`.
2. Run `setup-extract` to create a source-grounded extraction.
3. Review it, then run `setup-build-kb` to update canonical claims, experience files, bundles, and support data.
### Apply to a role
1. Run `make-resume` with the real JD.
2. Review the requirement table and fit gate before approving content generation.
3. Generate and validate the LaTeX resume.
4. Run `make-cl` only when the session records a justified `YES` decision.
5. Run `critique` for separate Evidence Fit, Document Quality, and Channel Strength findings.
6. Run `edit-resume` for approved repairs.
The skills live in `.agents/skills/`. Each application receives a session file under `output/<Role>/` that preserves the JD, fit decision, claim IDs, content plan, validation results, and application status.
## Validation
Validate the knowledge system:
```powershell
python resume_builder/helpers/validate_resume_system.py
```
Edit `config.md` with your details (name, email, provenance flags, role types). See `resume_builder/examples/example_config.md` for a complete example.
Validate a generated document:
### 2. Extract your papers
Place PDFs or `.tex` source files in `knowledge_base/papers/`, then:
```
/setup-extract knowledge_base/papers/my_paper.pdf
```powershell
python resume_builder/helpers/validate_resume_system.py --document output/Role/resume.tex
```
Claude reads the paper, asks clarifying questions about your contributions, and creates a structured extraction. Repeat for each paper.
Track the active 7/2/1 cohort:
### 3. Build your knowledge base
```
/setup-build-kb
```powershell
python resume_builder/helpers/cohort_tracker.py summary
```
This synthesizes all extractions into experience files, role-type bundles, and support files.
Character counts are available only as readability diagnostics. There are no fixed character bands, equal-length bullet rules, or page-fill quotas.
### 4. Customize your LaTeX templates
## Output and prerequisites
Open the templates in `resume_builder/templates/` and fill in your FIXED sections — education, header, awards, publications. The `[CONFIG: ...]` placeholders show you what to fill in.
The system writes `.tex` source only. Compile locally with a LaTeX distribution such as MiKTeX, TeX Live, or MacTeX. Generated resumes should also be checked through PDF rendering and text extraction before submission.
### 5. Generate for a job
```
/make-resume JDs/target_job.txt
```
Then in separate sessions: `/make-cl` for the cover letter, `/critique` for a scored review.
---
## How It Works
```
Your Papers --> /setup-extract --> Extractions --> /setup-build-kb --> Knowledge Base
|
Job Description --> /make-resume --> Tailored Resume/CV (.tex) |
| v |
/make-cl --> Cover Letter (.tex) |
| v |
/critique --> 8-Part Score + AI Scan + Fixes |
| v |
/edit-resume --> Refined Package |
```
| Skill | Purpose | Input | Output |
|-------|---------|-------|--------|
| `/setup-extract` | Extract structured data from a paper | Paper path | `knowledge_base/extractions/*.md` |
| `/setup-build-kb` | Build KB from extractions | All extractions | `resume_builder/{experience,bundles,support}/` |
| `/make-resume` | Generate tailored resume or CV | JD path | `output/<Folder>/e2e_*.tex` + session file |
| `/make-cl` | Generate matching cover letter | Session file | `output/<Folder>/*_cover_letter.tex` |
| `/edit-resume` | Edit resume/CV/CL from feedback | Session + feedback | Updated `.tex` files |
| `/critique` | Independent quality review | Session file | `output/<Folder>/critique_*.md` |
---
## Documentation
For architecture details, customization tables, the full critique system breakdown, key design decisions, and FAQ, see **[DOCS.md](DOCS.md)**.
---
## Contributing
Issues and PRs welcome. When contributing:
- Example files use the fictional Dr. Jordan Chen — keep examples in that persona
- Reference docs should stay domain-agnostic
- Test skill changes against the example data before submitting
---
See [DOCS.md](DOCS.md) for the architecture and policy reference.
## License
MIT — see [LICENSE](LICENSE).
MIT; see [LICENSE](LICENSE).