Innovate or Die

Ask an AI assistant for ideas and you tend to get the advice everyone else gets. This is a skill — a set of instructions you add to your AI assistant — that makes it search harder: it generates a large pile of ideas, has a second copy of the AI attack that pile in a separate session, keeps only what survives, and hands you one cheap experiment you could run this week. It is also built to tell you plainly when the boring, conventional answer is the right one. The goal is not novelty for its own sake; it is finding the valuable thing everyone walked past.

What you'll get back

• The best idea first, with the reason it should work — not just what to do, but why it would pay off.
• The ideas it threw away, and why each one died. This is more useful than it sounds: the objection to an idea you were about to try is worth having before you spend the money on it.
• One experiment, chosen to be the cheapest way to learn the most, with a clear number that counts as pass and a clear number that counts as fail.
• What it might still be missing — the assumptions it could not check and the facts it had to take on faith.

Get started

Pick the row for the app you use. Some rows install this as a plugin — an add-on package the app loads for you. A repo is this project's folder on GitHub; git clone copies it to your computer. Custom GPTs (ChatGPT), Gems (Gemini), Agent Builder (Microsoft 365), Projects and Computer skills (Perplexity), and Agent Skills are each platform's way of adding custom behavior to its AI.

If you're not sure, use Claude Code — it's two commands, and it's the setup this was designed for: the roles genuinely run in separate sessions there. Then read the first point under Good to know, because on Claude Code it doesn't always switch on by itself.

Then ask it something hard, or just say innovate or die.

Good to know

Sometimes it doesn't switch on, and won't tell you. The safest habit is to name it in your request instead of hoping the app notices the topic matches:

Use the innovate-or-die skill on this: we run residential pest control in three
towns and windshield time is eating us alive. what are we missing?

To check whether it actually ran: look at the first line. From v2.1.0 the answer opens with a marker naming the skill and the version that produced it, like ⟦innovate-or-die v2.1.0⟧. If that line is there, it ran — nothing else writes it.

If it is missing, that is a strong hint but not proof: a model that ran the protocol can still skip the line. The older tell still applies — no list of rejected ideas and no experiment with a pass/fail number means it didn't run. There is no error message either way; a run where the skill sat out otherwise looks exactly like an ordinary answer. In our published testing, the skill was installed for 7 runs on Claude Code and actually switched on in 3 of them (that is a raw count, not a rate — the sample is far too small to be one), while on Codex every one of the 5 v2.1.0 runs emitted the activation banner — though Codex exposes no tool-call stream, so there is no independent ground truth there. We do not know why: three explanations were proposed and all three turned out to be wrong. The write-up is in docs/NOTE-activation-variance.md.

It is slow and it eats your usage allowance, because it genuinely does more work — it generates dozens of ideas and discards them down to a few before it answers you. That cost is the trade. Formatting rules keep the output from sprawling, and nothing in the design rewards long answers.

It doesn't know your prices, your local rules, or your regulations. When an idea depends on a number or a law it wasn't given, it is instructed to say so and name what you need to look up, rather than invent a plausible figure. Look those up before you act on anything.

It's the wrong tool for two jobs. If you already have your options and just need to pick one, that's a decision, not a search. If you have the plan and need it carried out, that's execution. This does neither.

Does it actually work?

We tested it by running the same set of problems twice — once with the skill, once without, same question and same AI both times — and we did it on two different companies' AI systems. With the skill, the models reliably produce the protocol's full output structure — falsifiers, a kill list, an experiment spec — which they rarely produce unprompted. Whether that structure yields better decisions is not yet tested. And it is not always worth the cost: in one case the skill spent 19 times the tokens for no measurable gain — see the results.

For developers and evaluators

What it does

Six stages, four roles, one bounded correction loop:

1. Frame — restate the real problem, name what counts as the obvious answer.
2. Innovate — at least 10 assumptions classified real-vs-inherited, 5 reformulations, 8 lenses from distant fields, 30 candidates with mechanisms.
3. Critique (isolated) — a seven-test fake-novelty detector, a nine-probe adversarial checklist, and a falsifier standard. Killing 8–15 of 30 is normal.
4. Revise and select — reopen the territory the critic named, pick finalists on asymmetric potential, push each to its more radical version.
5. Gate — eight dimensions scored 1–5; pass needs every score ≥ 4.
6. Deliver — strongest thesis first, then the reframing, top opportunities with mechanisms, the most contrarian hypothesis, the cheapest high-information experiment, a compact kill list, and what may still be missing.

The quotas exist to force volume. Whether each quota earns its cost is untested — no ablation has been run.

What you get on each app (fidelity levels)

Keeping the roles apart is the design choice everything else rests on: an author who knows the filter optimizes for the filter. Hosts differ in how much real separation they can provide, so fidelity degrades in four known steps.

Level 1 — Agentic hosts with subagents. Claude Code, Codex, Copilot coding agent. The innovator and critic run in genuinely separate contexts. Full fidelity.

Level 2 — Copilot .agent.md profiles. One profile per role plus an orchestrator. The separation is real but manual: you open a fresh chat per role and hand forward only what the next role is entitled to see. Fidelity depends on you following that.

Level 3 — One context, staged reading. ChatGPT GPTs, Gems, Agent Builder, Perplexity Projects, and Perplexity Computer. The instructions file carries the principles and workflow, the role briefs live in an attached knowledge file read stage by stage. Two caveats — there is no true isolation, only discipline; and knowledge-file access is retrieval-mediated, so a role brief may in principle arrive in fragments. Tested once and passed: a verbatim quota-extraction probe on a Gemini Gem (2026-08-19) returned all eight Innovator quotas intact and exact, with no fragmentation of enumerated lines. ChatGPT GPTs and M365 Agent Builder use different retrieval implementations and remain untested.

Perplexity Computer sits here too, and is the most capable host on this rung. It is the only Level 3 host that installs as a full zip rather than a paste plus an attachment, and the only one that runs live web search inside the protocol — in testing it went and cited sources for an industry figure the argument depended on, instead of flagging it as something you should look up. It also draws on what Perplexity already knows about you: one run referenced four facts about the user's projects and location that were nowhere in the prompt, which is useful more often than not, but worth knowing before you use it on anything sensitive.

It is not Level 1. Level 1 would require Perplexity to dispatch the skill's stages as separate sub-agents, and on two observed runs it did not — the roles shared one context, the same as every other host on this rung. The install being excellent is not the same as the isolation being real, and only the second one moves a host up.

Level 4 — Single-paste fallback. Everything inlined in one document, for hosts that take no attachment. The whole protocol — including what the critic checks for — is in context from the first token, which is the anchoring failure the design exists to defeat. The inlined document (~25k chars, and growing with each protocol version) also exceeds every known instruction-field cap, so it may be truncated. Shipped because a documented degraded path beats an undocumented one, not because it is recommended.

Not every cap behind those levels is equally solid: the Gemini Gem limit is a lower bound we have watched hold, not a published figure, and the Perplexity Projects limit is reported by its help centre but never paste-tested. See docs/COMPATIBILITY.md, which states the method for each.

Evaluation

This skill is evaluated against itself: every test case runs twice, once with the skill and once without (the with_skill and without_skill arms), same prompt and model, and the delta is the result. The activation counts quoted above are over with_skill runs. Iteration-1 is the v2.0.0 two-provider baseline; iteration-2 re-measures the Codex workhorse tier under v2.0.1 after the ADR-002 Stage 0 fix, with N=3 majority-vote grading — each judgment made three times, majority wins, because AI graders vary — introduced after grader nondeterminism was measured.

The same table, generated from the files themselves and kept next to them, is at evals/results/README.md.

Note what this does not establish: role separation is not evidence. The evaluator is a quality gate, not proof of correctness. A protocol that scores itself well can still be wrong.

How this repo is built

core/ is the single source of truth. Every install surface above is generated from it:

python3 build/assemble.py            # regenerate
python3 build/assemble.py --dry-run  # show what would change
python3 build/assemble.py --check    # CI drift guard
pip install pytest && python3 -m pytest   # harness unit tests
python3 build/package.py             # build all three release zips into dist/
python3 build/validate_openai.py <zip>   # OpenAI directory rules, by tag

CI runs --check and the tests on every push. The tests cover the generator's two refusal mechanisms (a substitution that will not silently no-op, a reference check that will not let an unresolvable path ship), the packager's zip-layout assertions, and the eval harness's two corrected correctness bugs (matched-pair aggregation, strict-majority judging).

Releases

Release assets are built only by .github/workflows/release.yml, on a v* tag push. Running package.py by hand is for inspecting what a release would contain; it is not how anything gets published. The job re-runs the drift check and the tests, then refuses to go further unless the tag equals the version in core/skill-meta.json — without that guard, tagging v2.2.0 against an unbumped skill-meta.json would publish assets named …-v2.1.0.zip and every download link would point at a file that is not there.

Three zips ship per release. Two are the same skill package in incompatible layouts, because claude.ai wants the skill folder as the zip root and Perplexity Computer wants SKILL.md itself there; a zip built for one does not load on the other — it does not degrade, it fails. The third, innovate-or-die-openai-v….zip, is a different thing entirely: a plugin for the OpenAI Plugins Directory, with the manifest, the skills/ tree, the listing logo and the licence under one top-level directory and nothing beside it. It is the only asset carrying assets/ and LICENSE, and it deliberately omits .claude-plugin/.

Each layout is asserted against the finished zip before it can be uploaded, and the plugin asset additionally has to pass build/validate_openai.py — the directory's rules, each tagged OPENAI (the portal enforces it) or POLICY (ours), each carrying the source page and the date it was read. Both checks run on every build, not only under --check, because the release workflow does not pass --check. The quoted requirements are in docs/COMPATIBILITY.md; the submission materials are in docs/openai-submission/.

Assets are built from the tag with git archive, never from the working tree, and are reproducible: python3 build/package.py --ref vX.Y.Z rebuilds the published bytes. dist/ is gitignored and never committed.

Cutting a release, in four lines:

# 1. protocol change? write the ADR first — docs/ADR-00N-*.md
# 2. bump "version" in core/skill-meta.json
python3 build/assemble.py && git add -A && git commit -m "vX.Y.Z: ..."
git tag vX.Y.Z && git push && git push --tags

Generated trees are committed, because installers read the repo layout. Do not hand-edit anything outside core/ — CI regenerates and diffs on every push, so edits to generated files are reverted by the next build.

Protocol changes are ADRs with a semver bump: see docs/ADR-001-protocol-merge.md for why v2 merges a four-role architecture with quota-based enforcement, and docs/COMPATIBILITY.md for every host format fact with the date it was verified.

License

MIT © 2026 Ken Pendergast — kenpendergast.com