DEV Community: Michael Mitrakos

How I stopped an LLM from lying on your resume (grounding, in practice)

Michael Mitrakos — Sat, 11 Jul 2026 06:46:23 +0000

TL;DR: Telling an LLM "only use real information" in a system prompt is not a safeguard — it's a suggestion the model will ignore the moment a keyword filter rewards ignoring it. If you need a hard guarantee that generated text only makes sourceable claims, you have to build it outside the prompt: constrain generation to a fact store, then run a separate verification pass that rejects any claim it can't trace back to a source. Below is the pattern, with code.

I've been building an AI agent that writes and submits job applications (LandEarly — that's the context, not the point of this post). The single hardest requirement wasn't scraping job boards or automating Workday's form-from-hell. It was this:

The system must never claim the candidate has experience they don't have.

Sounds trivial. It is not. And the way most tools "solve" it — a stern line in the system prompt — is exactly why so many auto-apply tools produce resumes that fall apart in the first phone screen.

Let me walk through why the easy version fails and what actually works.

Why "just tell it not to" doesn't hold

Here's the naive approach almost everyone starts with:

const system = `
You are a resume writer. Tailor the candidate's resume to the job.
IMPORTANT: Only use real information. Never invent experience.
`;

The problem: the model has two instructions in tension. "Match this job" pulls toward inventing a Kubernetes bullet when the JD screams Kubernetes. "Don't invent" pulls the other way. Which one wins is non-deterministic, and it gets worse under exactly the conditions you care about — a strong keyword match the candidate doesn't actually have is the most tempting thing for the model to fabricate.

You cannot audit a vibe. If the guarantee lives only in the prompt, you have no guarantee.

Step 1: Generation can only see facts, and every fact has an ID

The first move is to stop feeding the model a blob of resume text and start feeding it a structured, addressable set of facts.

// The candidate's real history, as discrete sourceable units.
const factStore = [
  { id: "exp_01", text: "Built a React dashboard used by ~2k internal users at Acme" },
  { id: "exp_02", text: "Migrated a REST API to GraphQL, cut payload size ~40%" },
  { id: "skill_01", text: "TypeScript — 4 years, primary language" },
  // ...
];

Now generation is constrained: the model must write each resume bullet from a specific fact, and return the id it used.

const system = `
You tailor resumes. You may ONLY write bullets grounded in the FACTS provided.
For every bullet you output, return the exact id of the fact it is based on.
If no fact supports a requirement in the job description, DO NOT write a bullet
for it. Return JSON only:
{ "bullets": [{ "text": "...", "sourceId": "exp_01" }] }
`;

const res = await callModel({ system, facts: factStore, job: jobDescription });
const { bullets } = JSON.parse(res);

This alone changes the shape of the problem. We've gone from "trust the model" to "the model made a claim about its sources that we can now check."

Step 2: Never trust the claimed source — verify it

The model will sometimes cite exp_01 for a bullet exp_01 doesn't actually support. So the citation isn't the guarantee either. It's just a claim to be verified.

Two layers here. First, a cheap structural check — does the cited id even exist?

const byId = new Map(factStore.map(f => [f.id, f]));

function structurallyValid(bullet) {
  return byId.has(bullet.sourceId);
}

Then the real check: does the source fact entail the bullet? This is a separate, narrowly-scoped LLM call whose only job is entailment — no creativity, no tailoring, no incentive to please. Small model, temperature 0.

async function isEntailed(bullet) {
  const source = byId.get(bullet.sourceId);
  const prompt = `
SOURCE FACT: "${source.text}"
CLAIM: "${bullet.text}"
Does the SOURCE FACT fully support the CLAIM, with no added specifics
(numbers, tools, scope) that aren't in the source? Answer "yes" or "no".
`;
  const answer = await callSmallModel({ prompt, temperature: 0 });
  return answer.trim().toLowerCase().startsWith("yes");
}

The key insight: the verifier is a different job than the generator. The generator is optimizing to match the JD, which is precisely the pressure that produces fabrication. The verifier has no knowledge of the job at all. It can't be tempted, because it doesn't know what the tempting answer would be.

Step 3: Reject, don't repair

The last piece is a policy decision, and it's the one people get wrong: when a bullet fails verification, you drop it. You don't ask the model to "fix" it, because "fix" quietly becomes "make it pass," which is fabrication with extra steps.

async function groundedBullets(candidate) {
  const drafted = await draftBullets(candidate);       // step 1
  const checked = [];

  for (const b of drafted) {
    if (!structurallyValid(b)) continue;               // fake id → drop
    if (!(await isEntailed(b))) continue;              // unsupported → drop
    checked.push({ ...b, source: byId.get(b.sourceId).text });
  }

  return checked; // every survivor is traceable to a real fact
}

If that leaves the resume thin against a role, that's not a bug to paper over — it's signal. It means the candidate is a weak match for that requirement, and the honest product move is to surface that ("this role wants 5 years of Go; you have none") rather than fake it.

The part users actually see

Because every surviving bullet carries its source, the UI can show, next to each line, exactly which piece of the person's real history it came from. That turns "trust our AI" into "check our work" — the reviewer can see the receipts. It's also the single biggest trust feature we shipped, and it fell out of the architecture for free once grounding was in place.

What generalizes beyond resumes

Strip out the domain and this is a reusable pattern for any LLM feature where being wrong is expensive:

Make the source material addressable. Discrete units with IDs, not a text blob.
Force the generator to cite. Output must reference which unit it used.
Verify with a separate, incentive-free pass. The checker must not share the generator's goal.
On failure, drop — never auto-repair. Repair pressure is fabrication pressure.
Expose the sources to the user. Traceability is a feature, not plumbing.

It's the same instinct behind good RAG, just pointed at self-consistency instead of retrieval accuracy. And it's a lot more work than one line in a system prompt — but "don't make things up" is a requirement you either build for or you don't actually have.

If you want to see the end result in the wild, it's what runs under LandEarly. But mostly I wanted to write up the pattern, because there's shockingly little honest writing about the gap between "the prompt says don't hallucinate" and "the system provably doesn't."

How are you handling this in your own LLM features? Especially curious how others approach the verifier step — separate model, same model with a fresh context, or something structured like constrained decoding. Tell me in the comments.

Web Design Awards Has Rebranded — Built for Websites That Look Great and Perform Even Better

Michael Mitrakos — Fri, 03 Jul 2026 07:30:16 +0000

I’m excited to announce the rebrand of Web Design Awards, a platform built to recognize the websites, agencies, designers, developers, and brands pushing digital experiences forward. This rebrand is more than a visual refresh. It represents a clearer point of view on what great web design actually means today.

TLDR: Check out the new site, and get a 25% DISCOUNT on your website nomination or any purchase using the code REBRAND — valid till the end of July.

For a long time, web design recognition has been heavily focused on aesthetics. A beautiful homepage, an impressive animation, a striking color palette, or a clever interaction can capture attention quickly. Those things matter, and they always will. But a website is not just a visual artifact. A website is a business tool. It has a job to do, whether that job is generating leads, selling products, building trust, increasing signups, educating customers, or turning a visitor into a buyer.

That is the idea behind the new Web Design Awards. We believe the best websites are not just beautiful. They are strategic, discoverable, fast, persuasive, technically sound, and built around the user. They combine strong design with strong execution. They look good, but more importantly, they work.

The web has changed dramatically. Search is more competitive. AI is reshaping discovery. Users make trust decisions in seconds. Businesses expect their websites to contribute directly to growth. In this environment, great design cannot be separated from SEO, performance, accessibility, content strategy, user experience, and conversion optimization. A website that looks incredible but loads slowly, ranks poorly, confuses visitors, or hides the next step is only solving part of the problem.

With this rebrand, Web Design Awards is expanding the standard for what deserves recognition. We want to showcase websites that balance creativity with commercial impact. That means celebrating visual design, but also the deeper work behind effective digital experiences: clear messaging, intuitive navigation, technical SEO, mobile performance, accessibility, conversion paths, content structure, and the small details that make a website feel effortless to use.

This matters because recognition should create real value. For an agency, an award can help build credibility, strengthen proposals, support premium pricing, and give prospective clients another reason to trust the team behind the work. For a freelancer, it can become proof of quality and a way to stand out in a crowded market. For a startup or brand, it can signal polish, seriousness, and momentum. A strong feature is not just a badge to place in a footer. It is a credibility asset that can support sales, marketing, SEO, social proof, and brand authority.

That SEO component is especially important to us. Great work deserves to be discoverable long after launch week. When a project is featured on Web Design Awards, it has the opportunity to become part of a larger ecosystem of search-visible, category-driven recognition. Buyers, founders, marketers, and creative teams are constantly researching agencies, websites, inspiration, and examples of effective digital execution. We want Web Design Awards to become one of the places they find that work.

The conversion side is just as important. People rarely convert because of one isolated design element. They convert because enough trust has been built and enough friction has been removed. Awards, case studies, testimonials, press, client logos, performance, copy, and user experience all contribute to that decision. Our goal is to help strong websites earn recognition that can be used as leverage across the entire customer journey, from first impression to final proposal.

The new Web Design Awards has been redesigned with that broader mission in mind. The brand is cleaner, sharper, and more focused. The platform is built to make great work easier to discover and easier to understand. As we continue to grow, we’ll be expanding categories, improving project pages, adding more editorial depth, and creating better ways to highlight the strategy, performance, and people behind exceptional websites.

To celebrate the rebrand, we’re offering 25% off all products until the end of July. Use the code REBRAND at checkout to claim the discount.

If you’ve recently launched a website that deserves recognition, this is the right time to submit it. We’re especially interested in projects that go beyond surface-level design and show what modern websites should be: beautiful, fast, search-friendly, conversion-focused, and built with a clear understanding of the user.

The internet does not need another gallery of pretty screenshots. It needs stronger examples of websites that combine creativity with results. That is what we’re building with Web Design Awards: a platform for digital work that looks great, performs well, earns trust, and deserves to be found.

Explore the rebrand and submit your work at webdesignawards.io. Until the end of July, use REBRAND for 25% off any purchase.