How to Build an AI Engineer Resume

{
  "fixture": "SYNTHETIC EDUCATIONAL EXAMPLE — not a real vacancy or benchmark",
  "role": "Applied AI Engineer",
  "requirements": [
    {"id":"R01","requirement":"Build and maintain Python API services","class":"core_responsibility","importance":"core"},
    {"id":"R02","requirement":"Integrate LLM capabilities with product workflows","class":"required_technical_skill","importance":"core"},
    {"id":"R03","requirement":"Create evaluation and automated test coverage","class":"required_technical_skill","importance":"core"},
    {"id":"R04","requirement":"Implement retrieval or structured data integration","class":"required_technical_skill","importance":"core"},
    {"id":"R05","requirement":"Deploy services and handle operational failures","class":"systems_operations_expectation","importance":"core"},
    {"id":"R06","requirement":"Document decisions and collaborate asynchronously","class":"collaboration_communication_expectation","importance":"required"},
    {"id":"R07","requirement":"Operate Kubernetes workloads","class":"preferred_technical_skill","importance":"preferred"},
    {"id":"R08","requirement":"Work within the stated hiring region","class":"explicit_eligibility_constraint","importance":"hard_gate"}
  ]
}

evidence_id,project_or_work,responsibility,technical_stack,problem_or_context,action,known_result,evidence_type,evidence_reference,confidence,metric_support,notes
E01,Knowledge API,Owned API boundary,Python|FastAPI|LLM API,Support knowledge lookup,Implemented request validation and grounded response schema,Service returns citations for the fixed evaluation fixture,repository,https://example.com/evidence/e01,strong,unsupported,Synthetic record
E02,Retrieval fixture,Owned ingestion and retrieval,Python|PostgreSQL|pgvector,Grounded answer retrieval,Indexed documents and exposed ranked retrieval,24-document synthetic fixture is reproducible,evaluation_report,https://example.com/evidence/e02,strong,supported,Synthetic fixture count
E03,Evaluation harness,Owned deterministic checks,Python|Node.js|JSON Schema,Regression detection,Created fixed cases and schema assertions,12 deterministic cases execute locally,test_report,https://example.com/evidence/e03,strong,supported,Synthetic fixture count
E04,Provider adapter,Owned failure handling,Python|HTTP API|pytest,Transient provider failures,Added bounded retries and typed error mapping,4 retry-path tests pass,test_report,https://example.com/evidence/e04,strong,supported,Synthetic fixture count
E05,Container deployment,Owned service packaging,Docker|health checks|logging,Repeatable service startup,Packaged service and documented health behavior,Container exposes a documented health endpoint,architecture_note,https://example.com/evidence/e05,moderate,unsupported,No production scale claim
E06,Decision record,Coauthored interface decision,Markdown|JSON Schema|Git,Async collaboration,Documented schema trade-offs and review decision,Decision record preserves rationale and limitations,decision_record,https://example.com/evidence/e06,moderate,unsupported,Shared ownership stated
E07,Kubernetes tutorial,Completed introductory exercise,Kubernetes,Preferred orchestration exposure,Followed a tutorial deployment,No independent implementation evidence,learning_note,https://example.com/evidence/e07,weak,unsupported,Do not claim operational skill
E08,Workflow adapter,Owned integration mapping,Python|webhooks|queues,External workflow handoff,Mapped events and failure states,Local fixture demonstrates success and failure paths,repository,https://example.com/evidence/e08,moderate,unsupported,Synthetic record

requirement_id,requirement,importance,evidence_ids,evidence_strength,resume_action,gap_note
R01,Build and maintain Python API services,core,E01,strong,lead_with_evidence,
R02,Integrate LLM capabilities with product workflows,core,E01|E08,strong,include,
R03,Create evaluation and automated test coverage,core,E03|E04,strong,lead_with_evidence,
R04,Implement retrieval or structured data integration,core,E02,strong,include,
R05,Deploy services and handle operational failures,core,E04|E05,moderate,include,No production scale evidence
R06,Document decisions and collaborate asynchronously,required,E06,moderate,mention_briefly,Shared ownership
R07,Operate Kubernetes workloads,preferred,E07,weak,gap_do_not_claim,Tutorial exposure is not implementation evidence
R08,Work within the stated hiring region,hard_gate,,none,eligibility_check_not_resume,Verify before applying

{
  "fixture": "SYNTHETIC EDUCATIONAL EXAMPLE — not a real candidate or resume",
  "candidate": "Avery Chen — fictional",
  "sections": {
    "summary": "Applied AI engineer building Python services and evaluation workflows.",
    "skills": {"Languages":["Python"],"AI_LLM":["LLM integration"],"Infrastructure":["Docker","Kubernetes"]},
    "experience_projects": [{
      "name": "Synthetic knowledge service",
      "link": "github.com/placeholder",
      "bullets": [
        {"id":"B01","text":"Built a Python FastAPI knowledge service with grounded responses.","requirement_ids":["R01","R02"],"evidence_ids":["E01"],"numeric_claims":[]},
        {"id":"B02","text":"Operated production Kubernetes workloads.","requirement_ids":["R07"],"evidence_ids":["E07"],"numeric_claims":[]},
        {"id":"B03","text":"Improved response quality by 40%.","requirement_ids":["R03"],"evidence_ids":["E03"],"numeric_claims":[{"value":"40%","evidence_id":null}]},
        {"id":"B04","text":"Documented API decisions.","requirement_ids":["R06"],"evidence_ids":["E99"],"numeric_claims":[]}
      ]
    }]
  }
}

{
  "fixture": "SYNTHETIC EDUCATIONAL EXAMPLE — not a real candidate or resume",
  "candidate": "Avery Chen — fictional",
  "sections": {
    "summary": "Applied AI engineer building Python APIs with retrieval and deterministic evaluation evidence.",
    "skills": {"Languages":["Python"],"AI_LLM":["LLM integration"],"Backend_API":["FastAPI"],"Data_Retrieval":["PostgreSQL","pgvector"],"Infrastructure":["Docker"],"Testing_Evaluation":["pytest","JSON Schema"]},
    "experience_projects": [{
      "name": "Synthetic knowledge service",
      "link": "https://example.com/evidence/e01",
      "bullets": [
        {"id":"B01","text":"Built a Python FastAPI knowledge service with validated requests and grounded responses.","requirement_ids":["R01","R02"],"evidence_ids":["E01"],"numeric_claims":[]},
        {"id":"B02","text":"Implemented ranked retrieval over a reproducible 24-document synthetic fixture.","requirement_ids":["R04"],"evidence_ids":["E02"],"numeric_claims":[{"value":"24","evidence_id":"E02"}]},
        {"id":"B03","text":"Added 12 deterministic evaluation cases and 4 retry-path tests with typed provider errors.","requirement_ids":["R03","R05"],"evidence_ids":["E03","E04"],"numeric_claims":[{"value":"12","evidence_id":"E03"},{"value":"4","evidence_id":"E04"}]},
        {"id":"B04","text":"Packaged the service with a documented health endpoint and coauthored the schema decision record.","requirement_ids":["R05","R06"],"evidence_ids":["E05","E06"],"numeric_claims":[]}
      ]
    }]
  }
}

import { readFileSync } from "node:fs";

const base = process.argv[2] ? new URL(process.argv[2], `file://${process.cwd()}/`) : new URL("../", import.meta.url);
const read = (name) => readFileSync(new URL(name, base), "utf8");
const parseCsv = (name) => {
  const lines = read(name).trim().split(/\r?\n/);
  const headers = lines.shift().split(",");
  return lines.map((line, index) => {
    const values = line.split(",");
    if (values.length !== headers.length) throw new Error(`${name} row ${index + 2} has the wrong width`);
    return Object.fromEntries(headers.map((header, column) => [header, values[column]]));
  });
};

const role = JSON.parse(read("examples/synthetic-applied-ai-role.json"));
const evidence = parseCsv("templates/ai-engineer-evidence-inventory.csv");
const matrix = parseCsv("templates/role-requirement-evidence-matrix.csv");
const flawed = JSON.parse(read("examples/flawed-synthetic-ai-engineer-resume.json"));
const corrected = JSON.parse(read("examples/corrected-synthetic-ai-engineer-resume.json"));
const marker = "SYNTHETIC EDUCATIONAL EXAMPLE";
if (!role.fixture.startsWith(marker) || !flawed.fixture.startsWith(marker) || !corrected.fixture.startsWith(marker)) {
  throw new Error("Every fixture must retain its synthetic label");
}

const requirements = new Map(role.requirements.map((item) => [item.id, item]));
const evidenceById = new Map(evidence.map((item) => [item.evidence_id, item]));
const matrixById = new Map(matrix.map((item) => [item.requirement_id, item]));
for (const row of matrix) {
  if (!requirements.has(row.requirement_id)) throw new Error(`Matrix references unknown requirement ${row.requirement_id}`);
  for (const id of row.evidence_ids.split("|").filter(Boolean)) {
    if (!evidenceById.has(id)) throw new Error(`Matrix references unknown evidence ${id}`);
  }
}

function checkResume(resume) {
  const errors = [];
  const sections = resume.sections ?? {};
  for (const name of ["summary", "skills", "experience_projects"]) {
    if (!sections[name] || (Array.isArray(sections[name]) && sections[name].length === 0)) errors.push(`missing required section ${name}`);
  }
  for (const entry of sections.experience_projects ?? []) {
    if (!(entry.link ?? "").startsWith("https://") || /\s/.test(entry.link ?? "") || /placeholder|todo|<|>/i.test(entry.link ?? "")) {
      errors.push(`link ${entry.link ?? "<missing>"} is not an acceptable absolute HTTPS URL`);
    }
    for (const bullet of entry.bullets ?? []) {
      if (!bullet.text?.trim()) errors.push(`bullet ${bullet.id ?? "<missing>"} is empty`);
      if (new Set(bullet.evidence_ids).size !== bullet.evidence_ids.length) errors.push(`bullet ${bullet.id} repeats an evidence ID`);
      for (const id of bullet.evidence_ids) if (!evidenceById.has(id)) errors.push(`bullet ${bullet.id} references unknown evidence ${id}`);
      for (const id of bullet.requirement_ids) {
        if (!requirements.has(id)) errors.push(`bullet ${bullet.id} references unknown requirement ${id}`);
        else if (matrixById.get(id)?.resume_action === "gap_do_not_claim") errors.push(`bullet ${bullet.id} claims gap requirement ${id}`);
      }
      const numbers = bullet.text.match(/\b\d+(?:\.\d+)?%?/g) ?? [];
      for (const value of numbers) {
        const claim = (bullet.numeric_claims ?? []).find((item) => item.value === value);
        const support = claim?.evidence_id ? evidenceById.get(claim.evidence_id) : undefined;
        if (!claim || !support || support.metric_support !== "supported") errors.push(`bullet ${bullet.id} numeric claim ${value} lacks supporting evidence`);
      }
    }
  }
  return errors.sort();
}

const flawedErrors = checkResume(flawed);
const correctedErrors = checkResume(corrected);
const lines = [
  "SYNTHETIC EDUCATIONAL EXAMPLE — deterministic integrity checks only",
  `flawed_resume=${flawedErrors.length ? "FAIL" : "PASS"}`,
  `flawed_errors=${flawedErrors.length}`,
  ...flawedErrors.map((error) => `- ${error}`),
  `corrected_resume=${correctedErrors.length ? "FAIL" : "PASS"}`,
  `corrected_errors=${correctedErrors.length}`,
  "human_review_required=true",
];
console.log(lines.join("\n"));
if (flawedErrors.length === 0 || correctedErrors.length !== 0) process.exitCode = 1;

SYNTHETIC EDUCATIONAL EXAMPLE — deterministic integrity checks only
flawed_resume=FAIL
flawed_errors=4
- bullet B02 claims gap requirement R07
- bullet B03 numeric claim 40% lacks supporting evidence
- bullet B04 references unknown evidence E99
- link github.com/placeholder is not an acceptable absolute HTTPS URL
corrected_resume=PASS
corrected_errors=0
human_review_required=true