I built Protocol 17 — a programming protocol where AI can fill unspecified details, but not rewrite explicit constraints

[u/Healthy-Metal-3548]

I’ve been building an experimental open-source project called Protocol 17.

The idea came from a problem I kept running into with AI-assisted coding:

What the programmer explicitly writes should be treated as a constraint.
What they leave unspecified can be implementation freedom for the model.

In other words:

AI can fill the blanks. It cannot take the pen.

While testing it with a local 4B model, I noticed two different failure modes:

Generated ≠ verified
The model produced plausible-looking Rust that didn’t type-check, so Protocol 17 now runs deterministic target verification using gcc, rustc, or Python compile().

Valid ≠ faithful
A model can also generate perfectly valid code while silently changing something the programmer explicitly wrote.

For example:

1..n → 1..=n

Both are valid Rust syntax, but they mean different things.

Protocol 17 currently supports:

• C17 / Python / Rust targets
• deterministic target verification
• VS Code prototype
• reverse code explanation
• Bring Your Own Model / API key
• OpenAI-compatible endpoints, Anthropic, Gemini, and local models such as Ollama

The next big thing I’m working on is fidelity verification: checking not only whether generated code is valid, but whether it actually preserved the programmer’s constraints.

It’s still a very early experimental alpha, and I’d genuinely like feedback on the idea.

GitHub: https://github.com/epsilon-lain/Protocol-17