AI Protocol Kit is not a collection of magic prompts. It is a set of working contracts — explicit instructions you give to an AI before it starts a task, telling it how to approach the work, what to verify, what not to assume, when to stop, and what kind of output actually counts as done. Each protocol was shaped from real workflows: rough ideas that collapsed too quickly, repository reviews that invented facts, README files written for the wrong reader, and publication steps that skipped the checks that matter. The kit gives those workflows a repeatable structure.Documentation Index
Fetch the complete documentation index at: https://mintlify.com/XxYouDeaDPunKxX/ai-protocol-kit/llms.txt
Use this file to discover all available pages before exploring further.
Why protocols exist: the predictable failure modes
AI-assisted work fails in recognizable patterns. Knowing those patterns is what makes it possible to address them directly. Premature convergence. An AI receives a vague prompt and immediately produces a confident, polished answer — skipping the question of whether the prompt was even the right one. The output looks complete but answers the wrong thing. Protocols like Pre-Task Expansion and Idea Shaping interrupt this by requiring alternative readings and explicit scoping before any synthesis begins. Invented facts and evidence drift. AI tools summarize, paraphrase, and infer. In unstructured sessions, inferences quietly become claims, claims become evidence, and by the end the AI is defending a position built on its own summaries. Protocols like Field Findings & Bugs and System Reading enforce hard separations between what was observed and what was inferred. Wrong reader fit. AI writes fluently for a generic reader that does not exist in your actual workflow. The output is readable but useless for the specific person who needs to act on it. Output for Real Readers Protocol forces reader identity, purpose, and language register to be closed before drafting begins. Publishing before review. In agentic sessions, AI tools can move fast — committing files, pushing changes, deploying pages — without a human-readable gate in the loop. The GitHub and publication protocols add explicit confirmation checkpoints before any irreversible action.Situation-first selection
The right way to pick a protocol is by identifying the failure mode you want to prevent — not by recognizing the protocol’s name. Ask what can go wrong in this specific task, then find the protocol that addresses that failure directly. This is why the Protocol Map organizes protocols by failure mode rather than by category. A protocol that looks like it belongs to “GitHub work” may be exactly the one you need for a documentation publishing step, even if your project has nothing to do with GitHub.All 17 protocols
Idea Shaping Protocol
Turn a rough idea into a clear structure before asking AI to write, plan, design, or build anything.
Pre-Task Expansion Protocol
Stop AI from collapsing too quickly into the obvious answer by exposing alternative readings and tensions first.
Structural Shaping Protocol
Shape ambiguous input into operational form before synthesis, with gates, evidence level, and artifact direction explicit.
System Reading Protocol
Read the gap between declared intent and observable behavior to extract the operative principle of a system.
Output for Real Readers Protocol
Write reader-facing material with reader identity, purpose, tone, and language constraints closed before drafting.
HTML Page & Tool Briefing Protocol
Guide AI from raw intake to a complete implementation brief for a static HTML page, web surface, or local tool.
Field Findings & Bugs Protocol
Capture findings and bugs as structured artifacts while keeping evidence, inference, uncertainty, and promotion separate.
GitHub Repository Publication Protocol
Prepare a repository for clean GitHub publication with workspace audit, feature choices, and confirmation before push.
GitHub README Framing Protocol
Write or restructure a GitHub README from repository evidence, reader fit, and the real job the README must perform.
GitHub Pages Discovery Protocol
Prepare GitHub Pages sites with correct publication roots, discovery files, canonical URLs, and sitemap handling.
GitHub Badge & Telemetry Protocol
Decide which badges, counters, and analytics make sense for a repo or GitHub Page without adding vanity widgets.
Public Page Publication Protocol
Prepare, restructure, or publish a public page with metadata, accessibility, links, and publication risks closed before deploy.
HTML & Website Discovery Protocol
Prepare static HTML pages with machine-readable discovery files, head metadata, sitemap, and robots rules.
GPT Agentic Posture Contract
Make ChatGPT work more like Codex: tool-aware, grounded in real files, ledger-based, and willing to stop when not ready.
Triad AI Orchestration Protocol
Run a review loop between an executing AI and a reviewing AI over snapshots, repo state, and diffs with target authority preserved.
PHI-Lens Protocol
Handle non-trivial AI tasks where constraints interact and a flat compromise would hide the dominant force or asymmetry.
PowerShell WinForms Generator Protocol
Generate structured, runnable PowerShell WinForms applications with layout, controls, and event logic in a single pass.
What makes a protocol different from a system prompt
A system prompt sets a persona or a general disposition: “You are a helpful assistant” or “Always respond in formal English.” It shapes tone and style but says nothing about what to do when the task is ambiguous, when evidence is uncertain, or when the right answer is to stop and ask rather than produce. A chain-of-thought instruction tells the AI to reason step by step before answering. That is useful for calculation and logic, but it does not define gates, stop conditions, output contracts, evidence separation, or reader-specific constraints. A protocol is a working contract. It defines:- Scope gates — what must be established before work proceeds
- Stop conditions — when the AI should halt rather than guess
- Evidence rules — what counts as a finding versus an inference
- Output contracts — what the final deliverable must contain and what form it must take
- Review requirements — what must be confirmed before irreversible actions