DEV Community: Peng Zou

A small regression harness for citation-safe LLM rewriting

Peng Zou — Wed, 21 Oct 2026 06:24:42 +0000

LLM rewriting can make a paragraph read more smoothly while changing what it claims. If you build a writing assistant, evaluate preservation separately from fluency.

I work on PaperHumanizer, an academic rewriting tool. This post describes a small evaluation pattern you can adapt. It is an illustrative harness, not a claim that every rewrite passes it.

Start with explicit invariants

Take a synthetic example:

In a pilot involving 42 participants, the intervention was associated with a 12% reduction in response time (Lee, 2025). The study did not establish causation.

A revision can change sentence rhythm. It should not silently change 42 to 420, 12% to 21%, or association to causation. Keeping the citation string is necessary but does not show that the surrounding claim still matches the source.

Use a fixture rather than another model score

Here is a dependency-free JavaScript example:

const fixture = {
  required: ['42', '12%', '(Lee, 2025)'],
  forbidden: ['proved that', 'established causation'],
};

function checkRevision(text, fixture) {
  const missing = fixture.required.filter(s => !text.includes(s));
  const introduced = fixture.forbidden.filter(s => text.includes(s));
  return { missing, introduced, needsReview: missing.length > 0 || introduced.length > 0 };
}

const bad = 'The intervention proved that response time fell by 21% (Lee, 2025).';
console.log(checkRevision(bad, fixture));
// missing: ['42', '12%']; introduced: ['proved that']; needsReview: true

Write fixtures by hand for your examples. They can cover sample sizes, units, percentages, author-year references and domain terms. Avoid treating a generic regular expression as a complete citation parser: narrative references, numbered references and multiple studies in one parenthesis need different handling.

Include negative controls

A test suite that accepts the original paragraph proves little. Add deliberately broken outputs:

Swap a percentage or unit.
Remove a limitation sentence.
Keep the reference but attach it to a stronger claim.
Change a technical term to a near-synonym with a different meaning.
Return an empty response or an incomplete paragraph.

The substring check catches only some of these. In particular, it will miss a removed limitation unless the fixture explicitly requires it. It may also flag a harmless spelling or formatting change. Its purpose is to route a revision to review, not to certify accuracy.

Put the human comparison step in the product

For each paragraph, compare the source with the revision and ask:

Is the population, method and result unchanged?
Is uncertainty still expressed at the same strength?
Does each reference still support the claim beside it?
Were any facts or references added?

A clean automated result means only that the chosen invariants survived. Readability, factual consistency and source support still need review. A detector score does not answer those questions.

For an example workflow, PaperHumanizer's academic editor includes an original/rewrite comparison view, academic tone choices and text-file export. Rewriting requires sign-in and credits. Review the result against your sources and follow your institution's AI-use rules.

What preservation failures would you put in a fixture before shipping an LLM rewriting feature?

Disclosure: I work on PaperHumanizer. This article was prepared with AI assistance and reviewed before publication.

Debugging Tesla Paint Shop UV placement with a labeled grid

Peng Zou — Wed, 21 Oct 2026 03:02:04 +0000

A wrap PNG can decode correctly and still place a logo across a door seam or turn lettering sideways. File validation cannot tell you which part of a flat image lands on the hood.

A labeled UV grid is a simple diagnostic for that second problem. Replace the artwork temporarily with colored squares, coordinates and arrows. Look at the model preview, then adjust the actual artwork using what you observed.

Disclosure: I build Tesla Wrap AI. This article was prepared with AI assistance. The standalone canvas example below was tested in a browser; I have not validated this diagnostic on a physical vehicle. Gallery browsing, browser editing and PNG export on the product are free; optional AI generation uses credits.

What the grid answers

Use a unique label for each cell, rather than an identical checkerboard. A uniform checkerboard shows distortion but makes it harder to tell which source region you are seeing.

The labels answer three different questions:

Cell identifier: which source region is visible on a panel?
Arrow direction: how is that region oriented in the preview?
Cell boundary: where does the surface cross into an adjacent source region?

Coordinates here use the canvas convention: the origin is at the top left, x increases to the right, and y increases downward. An arrow pointing up in the PNG does not promise that it will point toward the front of a particular vehicle. Discovering that relationship is the point of the diagnostic.

Generate a grid with no dependencies

Create an HTML file with a canvas, a download button and a script. Everything is drawn locally; there is no upload or remote image dependency.

<canvas id="grid" aria-label="Labeled UV diagnostic grid"></canvas>
<button id="download">Download UV Grid.png</button>
<script src="grid.js"></script>

Put this in grid.js:

const canvas = document.querySelector('#grid');
const ctx = canvas.getContext('2d');
const size = 1024;
const cells = 4;
const step = size / cells;
canvas.width = canvas.height = size;

for (let row = 0; row < cells; row++) {
  for (let col = 0; col < cells; col++) {
    const x = col * step;
    const y = row * step;
    const id = row * cells + col;
    ctx.fillStyle = `hsl(${id * 360 / 16} 65% 38%)`;
    ctx.fillRect(x, y, step, step);
    ctx.strokeStyle = '#fff';
    ctx.lineWidth = 3;
    ctx.strokeRect(x + 2, y + 2, step - 4, step - 4);
    ctx.fillStyle = '#fff';
    ctx.font = 'bold 40px monospace';
    ctx.fillText(`${String.fromCharCode(65 + row)}${col + 1}`, x + 18, y + 60);
    ctx.font = '20px monospace';
    ctx.fillText(`x=${x} y=${y}`, x + 18, y + 94);
    // A drawn arrow avoids depending on a special arrow font.
    ctx.beginPath();
    ctx.moveTo(x + 128, y + 220);
    ctx.lineTo(x + 128, y + 132);
    ctx.moveTo(x + 105, y + 155);
    ctx.lineTo(x + 128, y + 132);
    ctx.lineTo(x + 151, y + 155);
    ctx.lineWidth = 8;
    ctx.stroke();
  }
}

document.querySelector('#download').addEventListener('click', () => {
  canvas.toBlob(blob => {
    if (!blob) return;
    const url = URL.createObjectURL(blob);
    const link = document.createElement('a');
    link.href = url;
    link.download = 'UV Grid.png';
    document.body.append(link);
    link.click();
    link.remove();
    setTimeout(() => URL.revokeObjectURL(url), 10000);
  }, 'image/png');
});

Use it with the exact vehicle layout

Start from Tesla's official custom-wrap repository, which separates vehicle generations and variants. Do not infer compatibility just because two images share dimensions.

Select the exact model and variant in the preview workflow you are testing.
Keep the intended artwork as a separate working file. Use the grid temporarily as the preview texture; if your workflow needs a panel mask, apply the matching template mask to a copy of the grid.
Inspect both sides of the vehicle and several camera angles. Record which labels appear on the hood, doors and smaller panels. A screen-left panel is not necessarily the vehicle's left side.
Note rotated arrows, reversed labels and discontinuities. These are observations about this model and preview setup, not a universal panel map.
Restore the artwork, adjust it against the correct template, and inspect again. Hide diagnostic and template guides before the final export.

If the editor you are using does not support texture replacement or the exact model, use another suitable preview workflow. Do not assume that a preview on a nearby variant is equivalent.

For a working visual reference, the Tesla digital-wrap gallery is a starting point: choose a model-specific design, inspect its flat image and available preview, and compare the placement. My product is one implementation of the workflow, not the source of Tesla's file requirements.

What I checked, and what this does not prove

In the browser test, the example exported a 1024 × 1024 PNG named UV Grid.png, measuring 103,761 bytes. I checked its PNG signature, IHDR dimensions, chunk checksums and compressed image-data decompression. The exact byte count can vary by browser or rendering environment.

Those checks establish basic properties of that generated file. They do not establish a particular vehicle's UV compatibility, verify a 3D model's mapping, or prove that the file will import into a vehicle. This is an opaque diagnostic grid, not a finished design or an official template. Masking, transparency and the final artwork need their own review.

Check the current requirements in Tesla's repository before final export. A preview screenshot is also a different asset from the texture PNG: downloading the screenshot does not give you the underlying UV texture.

Keep the diagnostic separate from the artwork

I would keep the grid out of the final texture by storing it as a separate development asset, alongside a small record of the model and variant used for each observation. That makes a later preview-model change easier to investigate without overwriting someone's design.

The same technique applies to other UV-based editors. A clear coordinate reference helps separate “the image file is valid” from “the image is mapped where the designer intended.”

Building a privacy-first PNG checker for Tesla digital wraps

Peng Zou — Mon, 19 Oct 2026 08:43:12 +0000

A convincing car render and a usable digital wrap are different deliverables. One is a picture of a vehicle; the other is a flat texture that must map onto particular body panels.

While building Tesla Wrap AI, that distinction became one of the most useful constraints in the workflow. This post explains a small browser-based companion tool: a local PNG preflight check, plus a prompt builder that makes panel placement explicit.

Disclosure: I build Tesla Wrap AI. The companion tools are free; AI generation on the main website uses credits. This article was prepared with AI assistance and checked against the companion implementation.

Start with the actual deliverable

Digital Paint Shop wraps change a vehicle visualization, not the physical paint or vinyl. A preview screenshot cannot substitute for the underlying wrap PNG.

A sensible workflow has three separate checks:

File checks: can the browser decode the image, and does the file satisfy basic format constraints?
Template checks: does the image use the correct UV layout for the exact vehicle generation and variant?
Visual checks: are the hood motif, door graphics and lettering where the designer intended?

Passing the first check says nothing definitive about the other two. Two square images can have identical dimensions and completely different panel maps.

Read the signature, not just the extension

An input with accept="image/png" helps people choose a file. It does not prove that the selected bytes represent a PNG. The companion checks the eight-byte PNG signature before attempting to decode the image:

async function hasPngSignature(file) {
  const bytes = new Uint8Array(
    await file.slice(0, 8).arrayBuffer()
  );
  const signature = [137, 80, 78, 71, 13, 10, 26, 10];
  return signature.every((value, index) => bytes[index] === value);
}

This is a format preflight, not a comprehensive security validator. A matching signature does not establish that every chunk is valid. The browser still needs to decode the file, and a server receiving uploads needs its own validation.

The checker also reports dimensions, file size and the filename separately. That makes a failure actionable: “dimensions do not match” is more helpful than a single unexplained “invalid file.” The current constraints are linked to Tesla's published custom-wrap requirements, rather than treated as permanent assumptions.

Keep the image local

For this task, a server upload adds no value. A File object already exposes the file size and lets JavaScript read a small byte range. An object URL lets the browser decode and preview the selected image without sending its contents anywhere.

There are two easy lifecycle mistakes:

Leaking object URLs: revoke the previous URL when replacing or removing a file.
Displaying stale results: if someone chooses a second image while the first is decoding, the first callback can arrive late. Use a monotonically increasing selection counter and ignore callbacks from earlier selections.

The companion limits local decoding to a bounded file size, clears old validation rows when a new selection starts, and provides a visible remove action. It does not read the image's metadata to infer a vehicle model; that would create false confidence.

Give generation the right constraints

The prompt builder is deliberately simple. It combines the selected vehicle version, a visual direction and symmetry preference with a few layout instructions:

Center the hood motif. Keep key artwork within panels, clear of seams; simplify small panels. Preserve the UV layout and canvas proportions.

It also asks for requested lettering to remain readable and never mirrored. These instructions are a starting point, not a guarantee. The real generation workflow still needs the correct template and visual inspection afterward. A text prompt alone cannot establish UV compatibility.

The generated prompt stays within the main editor's input limit. The Space does not run an image-generation model or silently consume credits; it links to the matching editor and asks the user to paste the prompt into the AI panel.

Try the companion

The Hugging Face Space contains the prompt builder and local PNG checker, with its static implementation visible in the Files tab. No personal image needs to leave the browser to run the checker.

For the full workflow, the digital-wrap gallery offers designs to inspect before opening a copy in the editor. Choose the exact model, inspect the flat texture and available 3D preview, then save the actual PNG.

The broader lesson applies beyond cars: validate the file, validate its coordinate system, and validate the rendered result as separate steps. Which part of that workflow would you want to automate next?