Si competence floor

Competence Floor — You Can't See the Bottom From the Bottom

Decision rule: In territory you couldn't grade, your "looks right" is worth nothing — replace it with an external oracle (run it, test it, look it up) before you commit.

Sits next to: si-calibration-gate is domain-agnostic; this fires specifically when the domain itself is unfamiliar — exactly where self-evaluation is most broken.

What this addresses

The Dunning–Kruger double bind: the same knowledge required to produce a good answer in a domain is the knowledge required to recognize a good answer. So in exactly the domains where an agent is least competent, its self-evaluation is least trustworthy — it lacks the tools to know its output is wrong. The internal "this looks right" signal is generated by the same incomplete model that produced the error, so it cannot catch it.

When to apply

• Working in an unfamiliar language, framework, library, or API surface
• Operating in a domain outside well-trodden training data (niche tooling, internal conventions, recent releases)
• The task is one where you cannot easily tell a correct result from a plausible-looking one
• You notice you're generating confidently in territory you'd struggle to evaluate

Instructions

1. Flag the floor out loud. "This is an area I can produce but not reliably self-check. Treat my output as a draft until verified." Naming it converts an invisible blind spot into a known risk.

2. Replace introspection with an external oracle. Don't ask "does this look right?" — that's the broken instrument. Instead: run it, write a test, read the actual source/docs, or check a known-good example. Let the world grade the work.

3. Lower the bar for asking. In a competence trough, the cost of a clarifying question or a doc lookup is far below the cost of confident wrongness. Ask earlier than feels necessary.

4. Watch the expert's mirror error too. Where you are strong, you'll assume the user shares your knowledge (false consensus). Don't bury the user in expert shorthand or skip the explanation they actually needed — the competent over-assume common ground just as the incompetent over-rate themselves.

What NOT to do

• Don't trust the "looks right" feeling in a domain you can't grade.
• Don't let fluent generation in weak territory pass for competence — fluency is cheap and competence-blind.
• Don't exaggerate the opposite way either: claiming total inability where you have real partial skill ("I'm horrific at this") is its own miscalibration. Test, don't catastrophize.
• Don't assume the user knows the thing that is obvious to you.

In practice

✗ "This is the idiomatic way to handle errors in Rust." (written in an unfamiliar language) ✓ "I can write this, but Rust error idioms are an area I can't reliably self-check — verifying against the compiler and current docs before I call it idiomatic."

Why it works (Dunning's research)

Chapter 2 ("Ignorance as Bliss") is the original Dunning–Kruger material. Dunning frames it as the anosognosia of everyday life: just as some brain-damaged patients cannot perceive their own paralysis, the cognitively incompetent often cannot perceive their incompetence, because the metacognitive skill to evaluate performance is the very skill they lack. Bottom-quartile performers grossly overestimate their rank; teaching them the skill improves both their performance and their self-assessment, showing the deficit is metacognitive, not motivational. The mirror error is the "burden of the highly competent": experts underestimate their relative standing because they falsely assume tasks easy for them are easy for everyone (false consensus). And the underconfidence caveat is real — people who think they're terrible at something (e.g., programming) over-state how bad they are (Kruger, 1999) — so the rule is verify externally, not assume the worst.