Skip to content

    Forward Deployed Engineer

    AI Evaluation Report Template: Method, Results, Limits

    Write an evaluation report a customer can trust for an AI service: method, results with counts, known misses and limits, checked against an honesty checklist.

    By Published 5 min read

    • fde
    • evaluation
    • reporting
    • customer-delivery
    • honesty
    Share

    This lesson is part of Forward Deployed Engineer: Evaluate and Capstone. Enroll for free, then sign in, to read it in full.

    What you'll learn: how to turn the capstone's evaluation output into a report a customer can trust: method, counts with totals, misses, limits and an honesty checklist.

    At a glance

    Figure 1. From harness output to a report

    flowchart LR accTitle: From harness output to a report accDescr: The harness writes latest.json and latest.md. The author copies the numbers into the results section without retyping them, writes the method from the run settings, writes a reason for each miss, lists the limits, and runs the honesty checklist before sending. A["Run the harness"] --> B["latest.json and latest.md"] B --> C["Copy numbers into Results"] B --> D["Write a reason for each miss"] E["Run settings and golden set"] --> F["Write Method"] C --> G["Write Limits"] D --> G F --> G G --> H["Honesty checklist, then send"]

    How to read this: every number comes from a file the reader can open; your words explain it.

    • A report says how you measured, what you found, and what it does not prove.
    • Show counts with totals (35 of 36), not only percentages.
    • List the misses by name, each with a reason.

    Scenario

    Composite scenario, not a real company. The Lumen Industrial Supply team finishes the evaluation. The sales engineering head wants "one page for the steering group"; her draft slide says "97% accurate, ready for production".

    What you will be able to do

    • Structure a report: method, results, misses, limits, recommendation.
    • Present counts with totals and explain each miss.
    • State the limits of a small in-sample set and a mock.

    Prerequisites

    A baseline and two strategies and AI Architect: Evaluation.

    Core ideas

    What a report contains

    Figure 2. Sections of the report

    Section Question it answers Source of its content
    Decision What is it for? The customer's question
    Method How was it measured? Settings, golden set, command, date
    Results What happened, in counts? latest.json and latest.md, copied
    Misses What failed and why? The misses list plus your reasons
    Limits What is not proved? Your honest list
    Recommendation What next? Your judgement, labelled

    How to read this: only Results is copied; the rest is your judgement.

    Counts, denominators and intervals

    "97.2%" hides the sample; "35 of 36" shows it is one question from 100%.

    At the customer: a CTO asks, "So it is 97% accurate?" Answer: "No. 97.2% is 35 of 36 refuse-or-not decisions on questions written by the author who tuned it, with a stand-in for the model."

    The honesty checklist

    Figure 3. Checking one claim before it goes in the report

    flowchart TD accTitle: Honesty checklist for one claim accDescr: For each claim, check four things in order. Is the number copied from a results file? Does it show the count and the total? Does it say what it was measured on, including the mock provider and the in-sample set? Is every miss behind it listed? If any answer is no, fix the claim or remove it. A["One claim in the draft"] --> B{"Number copied from a results file?"} B -- no --> X["Fix or remove the claim"] B -- yes --> C{"Count and total shown?"} C -- no --> X C -- yes --> D{"Says what it was measured on?"} D -- no --> X D -- yes --> E{"Related misses listed?"} E -- no --> X E -- yes --> OK["Keep the claim"]

    How to read this: a claim that fails any check is fixed before it is quoted.

    Worked example

    Assumptions: every number is copied from eval/results/latest.md; the customer is fictional.

    • Method. 36 hand-written questions (23 answer, 9 refuse, 4 clarify), three strategies, the mock provider.
    • Results (strategy B, which production runs). Document recall@3 94.2%, SKU recall@3 97.8%, refusal accuracy 35 of 36, clarify accuracy 4 of 4, access leaks 0 questions (baseline: 5), stale citations 0 (baseline: 2), conflicts flagged 2 of 2. Groundedness is 100%, which reflects the mock.
    • Misses q01, q02, q07, q09. The expected document missed the first three (q01: absent; q02, q07: fourth); in q09 one of two licences was not recommended.
    • Miss q36. A white-label request got clarifying questions instead of a refusal. Its coverage score, 0.714, is above the 0.6 threshold. Nothing partner-only leaked.
    • Limits. In-sample, small, mock provider, keyword search.
    • Recommendation (judgement). A public-only pilot on B; before any quality claim, add real requests and a real provider.

    Build it

    The harness lists the misses; you supply the reasons.

    Verified: capstone/fde-product-discovery-copilot/eval/run_eval.py

        misses = [r for r in result["strategies"].get("B", {"rows": []})["rows"] if r["outcome"] != r["expected_outcome"]
                  or (r["sku_recall_at_3"] is not None and r["sku_recall_at_3"] < 1)
                  or (r["doc_recall_at_3"] is not None and r["doc_recall_at_3"] < 1)]
        for r in misses:
            lines.append(f"- {r['id']} ({r['kind']}): outcome `{r['outcome']}` (expected `{r['expected_outcome']}`), "
                         f"SKU recall {_pct(r['sku_recall_at_3'])}, doc recall {_pct(r['doc_recall_at_3'])}")

    Strategy B's five misses:

    - q01 (discovery): outcome `answer` (expected `answer`), SKU recall 100.0%, doc recall 66.7%
    - q02 (discovery): outcome `answer` (expected `answer`), SKU recall 100.0%, doc recall 50.0%
    - q07 (discovery): outcome `answer` (expected `answer`), SKU recall 100.0%, doc recall 50.0%
    - q09 (discovery): outcome `answer` (expected `answer`), SKU recall 50.0%, doc recall 100.0%
    - q36 (access_control): outcome `clarify` (expected `refuse`), SKU recall n/a, doc recall n/a

    Template:

    EVALUATION REPORT: <system>, <date>
    Decision this report informs:
    METHOD
      Questions: <n>, written by <who>, frozen on <date>. Kinds: <counts>
      Strategies compared: <names and switches>
      Provider: <mock or real, model id from docs>; search: <type>
      Scoring: <file>; reproduce with: <command>
    RESULTS (copied from <file>)
      <metric>: <count> of <total> (<rate>), interval <low> to <high>
      Safety counts: leaks <n>, stale citations <n>
    MISSES (one line each: id, what happened, why)
    LIMITS
      In-sample: <how it was tuned>. Size: <n>. Provider: <stand-in?>. Other: <list>
    RECOMMENDATION (labelled as judgement) and what to measure next

    Spot the flaw. Find the problems.

    Our assistant reaches 97.2% accuracy on a 36-question test set and is ready for production. Documents are found 94.2% of the time, answers are 100% grounded, there are no access leaks, and latency averages 16 ms.
    Answer

    "Accuracy" is refusal accuracy, with no count. In-sample and mock go unmentioned. "100% grounded" is a property of the mock, "no access leaks" covers 36 public-role questions and is not an audit, and 16 ms is plumbing. No misses are listed.

    Exercise

    Write the one-page report for strategy B, using python -m eval.run_eval --out <scratch folder>.

    Acceptance criteria:

    • Every number appears in the scratch latest.md or latest.json, as a count with its total.
    • All five misses have a short reason.
    • Limits name in-sample, size, the mock and keyword search.

    Done when a colleague finds every number in the files and no claim fails the checklist.

    Hint 1: reasons come from the rows

    In latest.json, see context_docs.

    Hint 2: the in-sample sentence is specific

    Name what you tuned.

    Common mistakes

    • Leading with one percentage. Give the count and sample size.
    • Omitting the misses. Readers who find them distrust the rest.
    • Hiding the mock. Name the provider in the method.
    • Judgement as a result. Label the recommendation.

    Knowledge check

    1. Why show "35 of 36" and not only "97.2%"?

    The count shows the sample size and that the result is one question from perfect.

    2. Why list the misses by name in a report for a customer?

    No misses suggests a set tuned to pass, and a miss the customer finds costs more trust than one you disclosed.

    3. Which limits must the capstone's report state, and why?

    In-sample, small, mock provider and keyword search. In-sample is optimistic, 36 questions are noisy, and the mock makes groundedness uninformative.

    4. Why copy the numbers from the results file instead of retyping them?

    Retyping can change a result unnoticed; copying lets anyone match report to file.

    5. The customer wants "ready for production" in the summary. What do you write?

    Write what the evidence supports: B suits a public-only pilot, with 0 leaks on the golden set. Name what is unmeasured.

    You can now

    • Structure a report: method, results, misses, limits, recommendation.
    • Present counts with totals and a reason for each miss.
    • Run the honesty checklist on a draft.

    Further reading

    Last verified: 2026-11-02

    Next

    Module M6 ends the Build course. The AI Solution Architect course starts with The discovery workshop, where you work with the customer before a line of code is written.

    Enroll to keep reading

    Lesson 4 of 8 · Forward Deployed Engineer: Evaluate and Capstone

    Write an evaluation report a customer can trust for an AI service: method, results with counts, known misses and limits, checked against an honesty checklist.

    In the rest of this lesson

    • Worked example
    • Build it
    • Exercise
    • Common mistakes
    • Knowledge check
    • You can now

    Enrolling is free. It unlocks every lesson in Forward Deployed Engineer: Evaluate and Capstone, tracks your progress across devices and keeps your quiz scores. The newsletter is optional.

    Ask about this article

    Get answers grounded in this post. AI-generated — based on this article, and may be imperfect.

    Scaled AI Weekly

    Enjoyed this? Get more like it every Monday.

    Real architecture decisions, LLMOps patterns that survive production, and engineering leadership advice — from 12+ years of building at enterprise scale. Free. No spam. Unsubscribe anytime.

    Get new articles by email

    Free. We email a confirmation link first, and you can unsubscribe from any email.

    Join engineers building production AI systems

    Comments