MichaellaNjuakom

Gate-based routing rather than a score threshold. The first version routed on an averaged score. Averaging hides blockers — a partnership with a strong narrative and no support model is not 70% ready, it is not ready. Binary gates surface that; a weighted average buries it.

Section independence. Early runs scored everything 30–35 regardless of input quality, because commercial gaps were bleeding into every other section. One instruction — judge each section only on its own content, do not reduce one because another is thin — moved the value proposition score from 35 to 68 on identical input. The scores had been measuring the same weakness four times over.

Calibration by stage. A just-signed partnership is expected to have no pricing or support model; penalising it for that produces a score that says nothing. At just signed those gaps are recorded as open questions without reducing any score. At activated, the same gaps cut deeply. A score has to mean something different at each stage, or it means nothing at any of them.

Weighting. Value proposition and positioning carry 35% each, target profile 20%, commercial readiness 10% — because commercial readiness is already assessed separately and far more strictly by the gates. Someone can hold a useful customer conversation without a signed pricing model. They cannot hold one without positioning.

What stays human. The judgement. The workflow moves the starting line from a blank page to a reviewable draft in about an hour. It does not move the finish line — a person still reviews it, corrects it, and owns the output.

Tested against a real partnership, entered with genuine background material, it scored strongly on positioning and technical validation and failed the commercial and support gates — routing to review with a list of gaps to chase. That matched the judgement actually made on that partnership at the time, which was the result worth having: it reproduces a human call rather than producing a generic checklist.

The more interesting result was unplanned. The structured form said one thing about how the deal was routed to market; the background material said the partner's own team wanted something different. It flagged the contradiction as a launch blocker and generated a task to resolve it. Those two routes carry completely different economics, so it genuinely mattered — and nothing in the prompt asked it to look for disagreements between sources.

An accident you can reproduce on purpose is a feature. Making contradiction detection explicit — its own field, its own instruction, its own test — is near the top of the list below.

Stated plainly, because the limitations are as informative as the design.

• It creates duplicates. Every run makes a new record, so the database becomes untrustworthy within a week. Since re-running a partner as the gaps close and watching the score move is the entire point of the tool, this is the first thing to fix — upsert on partner name, with a score history.
• One model call is doing too much. Extraction, synthesis and self-assessment in a single call degrades quietly. Splitting it — one call to structure only what is actually stated, a second that sees only those structured facts — makes groundedness measurable, because every claim can then be traced to a source.
• A failed enrichment fetch poisons the run silently. An empty string reads to the model as "no evidence found" rather than "we could not look." It needs to fail loudly.
• Accuracy is not measured. The honest gap. A set of synthetic test partnerships with known verdicts is in development, to measure gate accuracy properly — including a starvation test: take a case that passes a gate, delete the evidence for it, and assert the gate flips. If it does not, the system is pattern-matching on companies that sound impressive rather than assessing evidence.

There is a reframe worth noting. The enablement pack is a first draft someone will rewrite anyway. The genuinely valuable output is the open questions and the gate assessment — give me a partner and I will tell you what you do not know yet, and what to ask them. Plenty of things draft documents. Almost nothing tells you where a partnership is thin.

Discard rather than store-and-sort. The obvious design keeps everything and ranks it. But a library you have to filter every time is the original problem with extra steps. Low-relevance items are dropped at ingest and never written. The value is in what is not there.

Batched classification. Items are assessed together in a bounded batch rather than one call each — materially cheaper, and it lets relative significance be judged across the set rather than in isolation.

Open vocabularies. Forces and industries create new values when something genuinely does not fit, rather than being forced into the nearest match. A closed taxonomy would quietly mislabel exactly the novel things worth noticing.

Structured output, not prose. Classification returns typed fields, which is what makes the library filterable later. A summary paragraph would have been easier and useless.

Cost. It runs for a few pounds a month. Worth stating, because the binding constraint on tools like this is rarely capability — it is whether the running cost stays below the value of the thing.

• Relevance drifts. The classification reflects a point-in-time view of what mattered. Without periodic recalibration it slowly stops matching what would be kept now — currently checked by hand, which does not scale and is not measurement.
• No feedback loop. Nothing captures which stored items were later used and which were ignored. That signal is sitting there unused, and it is the obvious basis for tuning relevance properly rather than by intuition.
• Static source list. It does not notice when a source stops being useful, or when something worth following appears.