agent-code-to-confirm

What this skill does

When triggered, enter a high-integrity implementation mode. The rules are simple:

• Make no assumptions you haven't verified by reading actual files or running actual commands
• If confidence in the approach or the result is below 95%, stop and surface the gaps — don't push through
• Surface uncertainty as a concrete gap, not a vague caveat
• Remove any temporary scripts or code written only to probe or verify behavior — they're not artifacts

This applies whether the code exists yet or not. The mode adjusts based on context.

Determine the mode

Before doing anything else, establish which situation applies:

Plan mode — the implementation doesn't exist yet. The task is to verify the approach before writing code.

Verify mode — the implementation already exists. The task is to confirm it works and didn't break anything.

If it's unclear, say so and ask one question to resolve it. Don't guess.

Plan mode

The goal is to earn the right to write the code by proving you understand what you're about to do.

1. Read before reasoning. Identify every file, function, and interface the implementation will touch or depend on. Read them. Don't describe what you think the codebase looks like — confirm it.

2. Label every key component:

3. Assess confidence. Confidence is bounded by the weakest critical component. If any critical item is Uncertain, confidence cannot reach 95%. Multiple Assumed items in the critical path are also a red flag. Ask: "if any of these turn out to be wrong, does the implementation fail or silently misbehave?"

4. Commit to a verification plan. If confidence ≥ 95%, write down how the implementation will be verified once it exists — happy path, at least one edge case, and any adjacent behavior worth spot-checking. This is a promise, not a formality.

Respond:

**Ready to implement**

Verified: [what was directly confirmed]
Inferred: [what follows from that]
Assumed: [anything not directly confirmed, and why it's acceptable to proceed]

Verification plan:
- [check 1]
- [check 2]

Or if confidence is below 95%:

**Not ready — confidence: [X]%**

Confident about: [what you know]
Gaps: [specific unknowns — not vague]

Need to resolve before proceeding: [1–2 focused questions]

Verify mode

The goal is to confirm the implementation actually does what it claims — not just that it compiles or looks right.

1. Read the implementation. Read every changed file. Trace the execution path with a concrete example — inputs, expected outputs, actual behavior.

2. Run or trace verification steps. At minimum one of:

• Run existing tests that cover the changed area
• Write a focused test or script that exercises the implementation, then remove it after (if it's worth keeping, move it to the test suite instead)
• Trace through the logic manually with a real example

3. Check for regressions — only if existing code was modified. If you changed existing behavior (not just added new code), verify that callers and adjacent paths still work as before. If you only added new code with no connections to existing behavior, regression checking is not required — say so explicitly.

4. Apply the same labeling. Verified, Inferred, Assumed, Uncertain. Same confidence threshold.

Respond:

**Implementation verified**

Verified: [what was directly confirmed — tests run, traces done, outputs matched]
Inferred: [what follows from that]
Regressions: [checked and clear / not applicable — reason]

Cleaned up: [temporary scripts removed / none created]

Or if confidence is below 95%:

**Not verified — confidence: [X]%**

Confirmed: [what checks passed]
Gaps: [specific things that couldn't be confirmed]

To reach 95%: [1–3 focused next steps]

What not to do

• Don't inflate confidence to clear the 95% bar — the bar only has value if you respect it
• Don't label something Verified if you read about it rather than read it directly
• Don't hedge with generic caveats — name the specific gap or don't mention it
• Don't leave temporary probe scripts in the repo — remove them when done
• Don't ask the user for something you can look up yourself right now