Debrief Specialist | Jodi Paige-Lee

The Problem

It Isn't a Writing Problem. It's a Decay Problem.

The insight is sharpest the moment I ship, and it does not survive the trip to a blank page. When a build lands I know exactly what I proved: the behavioral decision, the tradeoff, the constraint I solved. Days later the work is still solid and the angle has gone flat.

Publishing fast carries its own risk, though. Shipping something that isn't actually sharp. Or crossing a line I can't see at 10pm, like naming a client I'm under NDA not to name. So I hesitate, the window closes, and the gap between what I build and what the market can see me build gets wider.

Notes don't fix it. A notes app captures the brain download and leaves it raw, and raw is useless three days later. The structuring has to happen inside the capture, not after it. So this system doesn't tidy the dump. It transforms it into five finished structures in a single pass.

The two rules that override everything else

Rule 4 — Never fabricate a metric, never let unshipped work read as shipped. If I didn't give it a number, it does not invent one. In-progress stays legibly in-progress. Rule 5 — Honor the NDA. Protected names are stripped from every output without being asked, and it flags that it did.

These two outrank the voice guide, the templates, and anything I ask for in the moment. Everything else in the system serves the writing. These two serve the truth.

Architecture

One Download In, Five Structures Out

What the math checks

A publish gate runs seven deterministic checks over the LinkedIn draft. Two of them are honesty checks and they block the verdict rather than warn about it. The same two also run on the resume and pitch lines.

What the model judges

It locates the behavioral decision inside the dump and makes it the lead, then drafts all five artifacts in my voice.

What it refuses to say

Any number that isn't in the brain download, and any protected client name. It flags the hole instead of filling it.

The five artifacts

LinkedIn post draft

A near-finished post I trim, not a brief I build from. Claim-first, teaches one thing.

Case study outline

Six fixed parts: problem, decision, constraint, system behavior, evidence, outcome. If the dump can't support a part, it writes the part and flags the gap rather than inventing content for it.

Resume sentence

One line. Action verb, the decision, the outcome. No metric unless it's real.

Pitch sentence

The highest-altitude output. Not what the build does — what it proves about how I think.

Six carousel SVGs

1080×1080, fixed slide order: hook, problem, decision, principle, evidence, CTA. Because the thinking is already structured, the carousel costs almost nothing.

Carousel slides and the Gaps and Boosts panel generated from one brain download

Carousel output from a single run. Design system is locked: white ground, black illustration, one yellow highlight on the most specific sentence of slides two through five.

The folder self-checks. The app enforces.

The same seven checks exist in two places, and they are not equally binding. In the folder, the model runs them as a self-check and reports. In the companion app, they run as deterministic code, so the verdict holds whether or not the model cooperated.

That gap is the point. A must in a markdown file is a request. A must in code is a constraint. I built each at the layer where it is actually true, rather than writing "never fabricate" in a prompt and calling it a guardrail.

Proof

Seven Checks, and Only Some of Them Are Style

Five of these are craft rules about what performs on LinkedIn. Two are honesty rules about what's true. The distinction isn't cosmetic — it determines whether a failure stops the verdict or merely annotates it.

Check	Severity	Kind
No em-dash	Blocks	Voice
No link in body	Blocks	Reach
Four hashtags or fewer	Blocks	Reach
No throat-clearing	Blocks	Voice
No number absent from the dump	Blocks	Honesty
No protected client name	Blocks	Honesty
Word count 120–250	Advisory	Craft

The two honesty checks also run on the resume and pitch lines, because those travel without context and a recruiter reads them as finished fact.

Watch it fail on purpose

Most guardrails are invisible when they work, which makes them impossible to verify. So I committed a fictional client name, Northwind Realty, into the demo input on purpose. It trips the gate live. You can watch the refusal happen instead of reading a claim that it exists.

The real protected names live in a gitignored local file that was never committed, so the guardrail never had the thing it protects in the repo to begin with. Verifiable against the full history, not just the current tree — the command is in the README. And in the demo, the input names a client while the outputs say "a real-estate brokerage." I never told it to hide that. It did, and it flagged that it did.

The limit I'd rather state than hide

The unbacked-number check is an exact token match against the brain download. So if the download contains 3 weeks, a draft claiming 3% passes. It catches invented numbers, not every misused one. That's a real hole, it's documented in the README, and I'd rather name it than claim an airtight guarantee the code doesn't deliver.

Post-mortem

I Wrote a Rule I Called Non-Negotiable and Rendered It as a Suggestion

The publish gate shipped with two severity levels, fail and flag, and only fail counted toward the verdict. The check that catches an unbacked number was set to flag. Which meant the tool could print clear to publish directly above a metric it couldn't trace — the exact failure the gate existed to prevent, printed by the gate itself.

Before unbacked number → flag verdict → CLEAR TO PUBLISH The warning printed. The verdict ignored it.

After unbacked number → fail verdict → 1 CHECK FAILED The rule now decides what it was written to decide.

The interesting part isn't that a severity was wrong. It's that flag wasn't a bad idea — it's still in the code today, correctly, on word count. Word count is genuinely advisory. A 260-word post is a judgment call. An unsourced number is not a judgment call, and the two were sitting at the same severity because I'd been thinking about the checks as a list instead of as a hierarchy.

// Honesty rule, not a style rule: this blocks. Rule 4 is a hard rule, so a // number with nothing behind it cannot coexist with "clear to publish." const stray = unbackedNumbers(draft, dump); out.push({ k:'No number absent from the dump', status: stray.length ? 'fail' : 'pass' });

The fix was one word. The lesson wasn't. A guardrail is only as strong as the severity you assign it, and severity is a design decision, not a config value — it is the difference between a system that advises and a system that refuses.

Every rule I write now gets held against one question: if this fires and the verdict still says ship, what was the rule for?