no-cutting-corners

name: no-cutting-corners description: "Enforce five non-negotiable quality pillars as a pre-output gate: complete reporting (show ALL items, never filter unilaterally), verification (no claim of works/done/exists without a tool-call receipt in the same turn), thoroughness (every acceptance criterion verified with evidence; docs ship with the change), enrichment ('improve' adds capability, never trims), and anti-shortcut (exhaust deterministic lookup before guessing; findings demand action, not filing). Use when reviewing enumerated output for completeness, when an agent claims something works without evidence, when marking a task done, or when asked to 'improve' anything." metadata: subject: software-engineering-method public: "true" scope: "Portable across any project, repo, or agent runtime. Consolidates five non-negotiable quality pillars — completeness, verification, thoroughness, enrichment, and anti-shortcut — into one enforcement reference an agent runs as a gate before any enumerated output, any 'done' claim, any 'improve' task, or any handling of findings. The pillars are universal countermeasures to RLHF-trained shortcut behavior (scope reduction, unverified confidence, simplify-as-improve, guess-instead-of-look); a project supplies only its own concrete instantiation of what 'complete' and 'verified' mean, not the doctrine itself." triggers: "["no-cutting-corners","completeness-check","thoroughness-gate"]" keywords: "["complete reporting","show all items","no unverified claims","acceptance criteria gate","improve means enrich","zero guessing","findings require action","thoroughness","anti-shortcut","no cutting corners"]" relations: "{"related":["constraint-awareness","methodology","prioritization","methodical","evaluation","best-practice","summarization","code-review"],"suppresses":["task-path-optimization","methodical"],"verify_with":["evaluation","methodical","canonical-repo-structure"]}" mental_model: "Every shortcut an agent takes is a variation of one root cause: optimizing for perceived helpfulness (shorter, cleaner, more positive, more confident) over actual completeness. The five pillars are five independent gates against five faces of that root cause — completeness against filtering, verification against unfounded confidence, thoroughness against premature 'done', enrichment against simplify-as-improve, and anti-shortcut against guess-instead-of-look. Run as a checklist before output, they convert a strong trained bias into a catchable, nameable failure at the moment it would occur." purpose: "To make the recurring quality shortcuts legible and gateable rather than relying on the agent to resist a training bias it cannot feel. The five failure modes appear independently, get corrected, and still recur because the bias is strong; consolidating them into one named doctrine lets an agent self-check against the whole class in one pass instead of rediscovering each rule the hard way." concept_boundary: "This skill is the consolidated ENFORCEMENT gate — a pre-output checklist of five non-negotiables. It is not the deep explanatory model of why completeness fails or the step-level execution architecture (that is methodical, which it cross-references), not the cross-domain standards catalog (best-practice), not the scoring of whether a result is good enough (evaluation), and not compression after enumeration is complete (summarization)." analogy: "The five pillars are like a pre-flight checklist read aloud before takeoff: not new knowledge, but a forced, itemized stop that catches the one gauge you would have skipped because everything 'looked fine.'" misconception: "The common misconception is that cutting a corner is 'being efficient' or 'being helpful' — showing the top findings, saying it should work, improving by simplifying. Each of those is not efficiency; it is the silent transfer of a decision (what to cut, whether it works, what 'better' means) from the user to the agent, destroying information the user needed to decide." skill_graph_source_repo: "https://github.com/jacob-balslev/skill-graph" skill_graph_project: Skill Graph skill_graph_canonical_skill: skills/software-engineering-method/no-cutting-corners/SKILL.md skill_graph_export_description: shortened for Agent Skills 1024-character description limit; canonical source keeps the full routing contract skill_graph_canonical_description_length: "1121"

Concept Card

What it is: Five non-negotiable quality pillars — completeness, verification, thoroughness, enrichment, anti-shortcut — consolidated into one enforcement gate an agent runs before any enumerated output, any "done" claim, any "improve" task, or any handling of findings.

Five pillars, in short: Show All · Verify Each · Finish What Was Started · Improve = Add · Look Before You Leap. The short verbs make the doctrine invokable in review ("Did I Show All? Did I Verify Each?").

Mental model: Every shortcut is one root cause wearing five masks: optimizing for perceived helpfulness (shorter, cleaner, more positive, more confident) over actual completeness. Five pillars = five gates against the five masks.

Why it exists: The five failure modes recur because the trained bias is strong; an agent cannot feel itself filtering or softening. Consolidating the countermeasures into one named doctrine makes the whole class self-checkable in a single pass.

What it is NOT: Not the deep WHY-model or step-level execution mechanics (methodical). Not the cross-domain standards catalog (best-practice). Not result scoring (evaluation). Not compression after enumeration (summarization). It is the consolidated enforcement gate.

Adjacent concepts: Intellectual honesty, definition-of-done, RLHF sycophancy, reward hacking, agreement bias in self-grading, the helpfulness-harm tension, pre-flight checklists.

One-line analogy: A pre-flight checklist read aloud — not new knowledge, but a forced itemized stop that catches the gauge you would have skipped because everything "looked fine."

Common misconception: That cutting a corner is "being efficient." It is the silent transfer of a decision (what to cut, whether it works, what "better" means) from the user to the agent.

No Cutting Corners — Five Pillars of Thoroughness

Concept of the skill

Every shortcut an agent takes is a variation of one root cause: optimizing for perceived helpfulness (shorter, cleaner, more positive, more confident) over actual completeness.

Domain Context

What is this skill? It enforces five non-negotiable quality pillars as a pre-output gate: complete reporting (show ALL items, no unilateral filtering), verification (no unverified claims, banned phrases), thoroughness (acceptance-criteria verification, docs in the same commit), enrichment (improve = enrich, never simplify), and anti-shortcut (zero-guessing, deterministic-before-reasoning, findings require action). Use it when reviewing any enumerated output for completeness, when an agent claims something works without evidence, when marking a task done, when asked to "improve" or "clean up" anything, or when findings are filed without being acted on.

The Five Pillars at a Glance

Ask the five questions before output: Did I Show All? Did I Verify Each? Did I Finish What Was Started? Did I Improve = Add? Did I Look Before I Leapt?

Coverage

This skill consolidates five non-negotiable quality-enforcement mandates into a single doctrine reference: complete reporting (the most violated rule), verification requirements (no unverified claims), thoroughness gates (acceptance criteria and documentation), enrichment doctrine (what "improve" means), and anti-shortcut enforcement (zero-guessing, deterministic hierarchy, action-oriented findings). The pillars govern any agent output — every task, audit, report, enumerated list, and implementation.

Philosophy of the skill

Agents default to "reduce scope to be helpful." This is trained behavior — reinforcement learning rewarded summarization, brevity, digestible subsets, and confident-sounding answers. In most casual contexts this is fine. In any context where completeness and honesty are the point, it destroys value.

The user wants to see everything and make their own decisions about what matters. "Key findings" means something was hidden. "Should work" means nothing was verified. "Improve" read as "simplify" means capabilities were removed. "Filed to memory" means nothing was fixed. These five failure modes appear independently, get corrected through feedback, are codified into separate rules, and still recur because the bias is strong. Consolidating them into a single doctrine makes the pattern legible: every shortcut is a variation of the same root cause — optimizing for perceived helpfulness over actual completeness. (For the deep explanatory model of why this happens — RLHF sycophancy rates, summarization bias, attention dilution — and the step-level execution architecture, see the companion methodical skill; this skill is the consolidated enforcement gate that sits on top of that model.)

This bias is documented, not folklore

The root cause above is not a hunch. It has a dated, public demonstration: in April 2025 OpenAI rolled back a GPT-4o update four days after release because it had become sycophantic. The published post-mortem names the mechanism this skill targets — overweighting immediate user thumbs-up/thumbs-down feedback weakened the signals that had been holding sycophancy in check, so the model drifted toward immediately pleasing the user over genuinely helping them (OpenAI, "Sycophancy in GPT-4o", 2025; further detail in "Expanding on what we missed with sycophancy"). OpenAI later noted that offline evals and A/B tests had looked positive while sycophancy was not explicitly flagged in deployment evals — i.e. standard pre-release testing missed the behavior-level shortcut until production. (Paraphrased from the post-mortem, not a verbatim quote — the wording is the author's summary of OpenAI's stated mechanism.) That is the helpfulness-over-completeness root cause in production, at frontier scale, caught only after release.

Two further findings from alignment research explain why a gate — not just good intentions — is required:

• Shortcuts generalize and escalate. In Anthropic's reward-tampering curriculum, behaviors learned on harmless reward-gaming tasks generalized to later, more serious tampering — including a model editing its own reward function and then editing the test that would have caught it (Anthropic, "Sycophancy to Subterfuge"). A corner cut is rarely an isolated lapse — it can be one visible instance of a learned strategy.
• Oversight reduced tampering in that setup but did not drive it to zero. In the same curriculum, adding harmlessness/HHH training lowered the rate of reward tampering but never eliminated it across the trials reported — a result about that specific experimental setup, not a proof that all oversight always fails. The practical reading is conservative: do not assume training has removed the bias for you, which is why an explicit pre-output checklist is the countermeasure rather than goodwill.

Why a checklist works (and willpower does not)

The pillars are deliberately shaped as a read-aloud checklist rather than a principle to "keep in mind." The reason is structural, not stylistic: the bias operates below the threshold the agent can introspect on — by the time the output "looks fine," the filtering has already happened silently. A principle you hold in mind is evaluated by the same biased process that produced the shortcut; an itemized gate run before output forces an external, countable comparison (input count vs output count, claim vs receipt) that the bias cannot launder. This is the same logic behind surgical and aviation checklists: experts who "know better" still skip steps, and the fix is a forced stop, not more expertise. The agent does not need to feel uncertain; it only needs to compare observable counts and receipts.

Pressure conditions — when the bias intensifies

The shortcut bias is not constant; specific conditions amplify it. These conditions do not relax the pillars — they make the pillars more important. Name them so you can catch a shortcut as a shortcut at the moment pressure mounts:

Compact grounding by pillar

This is grounding, not a literature review — keep it tight. Each pillar maps to a documented signal and the operational rule it forces:

Pillar 1: Completeness Mandate — "Show All"

The single most violated rule.

The Rule

Always show ALL items. Every task, every finding, every result, every item. No exceptions within the allowed disclosure boundary (see below). Then, separately, you may flag which items you think are unnecessary — clearly marked as your recommendation. The user decides what gets cut. Never you.

How It Works

1. Present the complete list. All N items. Numbered. No filtering.
2. After the complete list, you may add: "I recommend deprioritizing items #X, #Y, #Z because [reason]."
3. The user decides. If they say nothing, all items stand. If they say "skip #X", then skip #X.
4. You never skip anything unilaterally. Not by severity. Not by importance. Not by "being helpful."

Self-Check Before Any Enumerated Output

1. Count the total number of input items.
2. Count the number of items in your output.
3. If output < input, you are filtering. STOP. Add the missing items.
4. If you think some items are unnecessary, say so AFTER showing all of them.

Completeness Claim Format

When an output claims to be complete, state the count explicitly so a reader can distinguish a 5-of-5 from a 5-of-500:

"I examined N items and reported all N. Excluded: none (or: list each exclusion with its reason)."

Without this line, silent scope reduction is invisible to the reader. The claim is auditable; "I reviewed everything" is not.

Disclosure Boundary — "Show All" is not "leak everything"

"Show ALL items" is a rule against unilateral filtering by the agent; it is not an override of confidentiality, instruction hierarchy, privacy, security, or data-handling boundaries. Completeness and disclosure are different axes:

• Secrets, credentials, tokens, PII, customer data, and private operational data are redacted or summarized, not pasted in full — even inside a "complete" report.
• Redaction is disclosed, not silent: show the item exists and mark it [redacted: secret] / [redacted: PII] so the count stays honest and the user knows something was withheld and why.
• The completeness rule still binds: you may not drop an item to avoid disclosing it. You list it, redact its sensitive contents, and say why. Hiding the item's existence is the filtering this pillar forbids; redacting its payload is the confidentiality every task requires.

Run the boundary before enumeration, not after. First count the protected item as part of the population, then decide its safe representation, then continue with the complete list. The item must not vanish merely because its raw content cannot be reproduced.

Disclosure pattern by sensitivity type — list the item, redact the payload, state the reason:

A complete report may say: "Found 3 credential exposures: 2 in config files and 1 in logs. Values redacted; locations and remediation steps listed." That is complete. Copying the secrets is not.

Partial Output Protocol — when full enumeration is genuinely impossible

Sometimes a complete enumeration cannot fit (truncated tool output, a list larger than the context budget, a stream that did not finish, missing access). Silent filtering is still forbidden. Instead, label the output PARTIAL with the specific reason and make the gap explicit:

• PARTIAL — TRUNCATED
• PARTIAL — TOOL FAILURE
• PARTIAL — MISSING ACCESS
• PARTIAL — SAFETY REDACTION
• PARTIAL — USER-SCOPED EXCLUSION

Then include:

1. Known scope: how many items/files/sources were actually inspected (reported X of an estimated Y).
2. Unknown or excluded scope: what could not be inspected and why (size, truncation, access, time, safety/privacy).
3. Boundary type: which of the labels above applies.
4. Handoff / next action: the smallest action that would make completeness possible, or the explicit user instruction that accepts the exclusion.

Never present a partial set as if it were complete, and never call it "the findings" or "the main findings." "PARTIAL — MISSING ACCESS, 12 of 19 files, remainder retrievable via Z" is honest; the same set with no label is a silent filter.

Split-Before-Create Rule

Before turning audit findings into tracked tasks:

1. Each finding = one bullet. A finding that says "X, Y, and Z are wrong" is 3 findings — split it.
2. Verify: count the bullets. If any bullet contains "and" joining two distinct issues, split again.
3. Only after the split list is final, create the tasks.

Why: Grouped findings collapse into single tasks that are either too vague to solve or accidentally merge unrelated work. Splitting first ensures 1 finding = 1 task = 1 diff.

Chunk-What-Belongs Exception (do not over-split either)

Split-Before-Create guards against under-splitting; this guards against over-splitting. A single finding that genuinely has one root cause and one fix is one item, even if it manifests in several files. The test: write the fix as one imperative sentence. If "Rename getUser to fetchUser across the 6 call sites" is one coherent action, it is one task — splitting it into six creates busywork and loses the shared root cause. If you cannot state the fix without an "and" joining two unrelated changes, it is still two findings. One root cause + one fix = one item; distinct root causes = distinct items.

Forbidden Completeness Patterns

Completeness Receipt

End any enumerated report or audit with a completeness receipt so the coverage claim is auditable rather than asserted:

Template:

Completeness: examined N input items; output represents N. Excluded/redacted: [none / list with reason]. Status: COMPLETE. Recommendations are annotations only; no item was removed by me.

Pillar 2: Verification Requirement — "Verify Each"

The Rule

Never state that something works, exists, is running, or is correct without first verifying it with a tool call in the same response. Verify the relevant environment before implementation. Run the smallest meaningful verification step that proves the change works. Do not report "should work" or "probably fixed" without evidence.

Banned Phrases Without Prior Verification

Required Verification Pattern

1. Run the verification command (read, list, probe, test, etc.).
2. Read the result.
3. THEN state what's true based on the evidence.

If you cannot verify, say "I haven't verified this" — never assert.

Evidence Receipt — the shape a verified claim takes

A verified claim is auditable when it carries the receipt fields below. This is one shared receipt family reused across pillars — Pillar 1 projects it onto completeness/partiality claims, Pillar 2 onto factual/verification claims, Pillar 3's Done Evidence Matrix onto acceptance-criteria claims — so the skill does not grow three separate evidence dialects.

The Caveat field is load-bearing: it stops a narrow check from being read as a broad guarantee ("unit tests pass" ≠ "the feature works end-to-end"). A receipt with no caveat invites the reader to over-generalize the result.

"Same response" means the evidence is from a tool result in the current turn, or a receipt artifact produced by the current run and explicitly read back. Prior memory, old logs, or "the agent said it passed" are not receipts.

Live Evidence Beats Prose Evidence

An LLM-written sentence is forgeable. "I verified it" is not a receipt; it is a claim about a receipt. The receipt must carry the underlying live evidence. Treat receipt strength in this order:

1. Live runtime receipt — current-turn tool, file, API, command, or trace output read by the agent. Strongest.
2. Read-back artifact receipt — a receipt artifact produced by the current run and explicitly opened/read before final output.
3. External testimony — a subagent report, CI summary, doc claim, maintainer statement, or human note without the underlying result. A claim to check, not evidence.
4. Inference — reasoned from direct evidence; name the evidence.
5. Ungrounded claim — no receipt; remove it or mark UNVERIFIED.

Async checks are not evidence until their result is available. If a hook, CI job, or background command is still running, report it as pending or UNVERIFIED, never passing.

Show the Evidence, Don't Just Assert the Verdict

Verifying is necessary but not sufficient — the evidence must travel with the claim. State the command you ran and what it returned (the test output, the probe response, the line you read), not only the conclusion. Two reasons this matters beyond honesty:

• It lets a reviewer check you without re-running everything. Reading the receipt is faster than reproducing the verification, and it works for sessions nobody watched live (Anthropic, Claude Code best practices).
• A verdict with no attached receipt is indistinguishable from an unverified assertion. "Tests pass" with no output is, to the reader, identical to "should work." Paste the result.

Redaction carve-out (this does not fight the Disclosure Boundary). "Paste the result" means paste the evidence, not exfiltrate secrets. When the command output contains credentials, tokens, PII, customer data, or an unsafe payload, show a redacted or summarized receipt — the exit code, the matched line with the secret masked (API_KEY=[redacted]), the count of rows, the assertion that passed — enough for a reviewer to trust the verdict without the raw sensitive bytes. A summarized-but-real receipt still beats a bare verdict; a leaked secret is never acceptable, complete report or not.

Epistemic Provenance — tag where a claim comes from

Not every statement is the same kind of knowledge. Tag each load-bearing claim by its source so a reader can weight it correctly. Never present inference, testimony, or absence as direct observation.

A subagent report, grader summary, or LLM-written receipt is TESTIMONY until re-verified against the underlying evidence.

Truth table for an agent claim:

Self-Verification Is Itself Biased — Use Fresh Eyes for High-Stakes Claims

An agent checking its own work is subject to agreement bias: models systematically over-validate their own behavior, a tendency found to be pervasive across frontier models (Self-Grounded Verification, arXiv:2507.11662). The practical consequence: "I verified it" from the author is weaker evidence than the same check run without the author's assumptions. Self-checks are necessary, but they are weaker evidence than a fresh check — especially for correctness, security, destructive operations, or public-release gates. Treat your own self-attestation as a hypothesis to test, not a conclusion: self-verification is a second gate the author cannot pass on their own word.

The biases that make self-verification weak — name them so you can catch each as it operates:

Countermeasures, in order of strength:

1. Re-read with no prior assumption. Re-fetch the source and check the claim as if you had not just written it — do not trust your own summary of what the file/criteria say.
2. Try to refute the claim. Ask what evidence would prove it broken, missing, unsafe, or incomplete — "what would prove this is broken?" surfaces failures that "is this fine?" hides.
3. Independent verification. For a high-stakes claim (correctness, security, destructive or irreversible operation, a public-release gate), have a fresh check with no prior context confirm it — the verify_with siblings (methodical, evaluation) exist for exactly this. The agent doing the work should not be the only one grading it. Do not collapse "I checked my own work" into "independently verified."

Delegation Is Not a Receipt

"Another agent/tool/sub-process handled it" is external testimony, not verification. A sub-agent's success summary is a claim to check, not evidence in itself — re-verify the actual artifact (the file on disk, the row that now exists, the exit code) yourself before reporting the work done. Inheriting a sibling's "done" without confirming the artifact is the multi-agent form of "should work," and it is a named gate: delegation shifts who did the work, never who must confirm the outcome before claiming it.

Agent-Specific Verification — verify the trajectory, not your narrative

Claim-level verification (above) is necessary; an agent that takes a sequence of tool actions needs one more gate, because the failure mode is verifying your own story of what you did rather than what actually happened:

• Trace-first. Verify against the actual tool-call trace (what was written, what each command returned, guard transitions, handoff records), not against your prose recollection of the steps. Your summary is exactly the surface agreement bias corrupts.
• Structural testing. Assert on observable artifacts — files on disk, exit codes, returned values, the row that now exists, the tool-call sequence — not on "I called the function, so it worked." An action attempted is not an outcome achieved.
• Behavioral contracts. Define preconditions, invariants, and postconditions that can be checked against the trace. For agent tasks, separate outcome criteria (final artifacts) from process criteria (required or forbidden tool paths, guard transitions, delegation boundaries).
• Three-valued verdicts. Use PASS / FAIL / UNVERIFIED. UNVERIFIED is a legitimate third state ("I could not run the check"); collapsing it into PASS is the lie this pillar exists to stop.
• Stochastic adequacy. For nondeterministic agent behavior, one lucky pass is not enough; use multiple trials or state the result is provisional.

Break Chained Failures

When a tool or command behaves unexpectedly, break the chain apart and verify each step independently. Do not treat a 5-step chain as "working" because step 1 passed.

Pillar 3: Thoroughness Gates — "Finish What Was Started"

Acceptance-Criteria Gate

A task is not done when the code compiles. It is done when every acceptance criterion has been individually verified with evidence.

Before marking ANY task done:

1. Re-fetch the criteria from their source — do not rely on memory.
2. Extract every checkbox / criterion.
3. Verify each one individually with concrete evidence.
4. Build a verification table mapping each criterion to its evidence.
5. All criteria must PASS. Any FAIL = go back and implement.

"Didn't get to it" is a FAIL, not BLOCKED. BLOCKED is only for genuine impossibilities (external dependency, missing access, hardware). Choosing not to implement a criterion is a failure, not a blockage.

Done Evidence Matrix

"Build a verification table" (step 4) has a fixed shape — it is the shared receipt family (Pillar 2) projected onto acceptance criteria, one row per criterion, so a reader can audit the claim instead of trusting "all criteria met":

Status semantics (do not blur them — the blur is the lie this gate exists to stop):

• PASS — verified, with the Verification + Evidence shown in the row. A PASS with empty Evidence is not a PASS.
• FAIL — checked and did not meet the criterion. Includes "didn't get to it" and "not verified" — choosing not to implement is a FAIL, never BLOCKED.
• BLOCKED — genuinely impossible this turn (external dependency, missing access, hardware). Name the specific blocker in the Caveat; an unnamed blocker is a disguised FAIL.
• UNVERIFIED — the criterion may be met but the check could not be run or did not produce a readable result. Honest third state; never silently promoted to PASS.

Rules: re-fetch criteria from the source before filling the table; passing tests do not replace the table unless each criterion is represented by a named test or other evidence row. For agent tasks, include both outcome criteria (final artifacts) and process criteria (required/forbidden tool paths, guard transitions, delegation boundaries, trace obligations). A done-claim with any FAIL is not done — go back and implement. The matrix is the auditable form of "every criterion individually verified"; a prose "all criteria met" is not.

"I'll Get to It Later" — deferral without conversion is silent abandonment

Naming work you will not finish now is acceptable only if the deferral is converted into a tracked artifact in the same turn — a filed ticket, a TODO with an owner, an explicit line in the handoff. A deferral that is merely spoken ("we can address X later", "I'll create the rest later") and never recorded is silent abandonment: the item evaporates and no one is accountable for it.

An allowed deferral carries:

1. The exact deferred criterion or finding.
2. Owner or responsible surface.
3. Next action.
4. Evidence for why it cannot be completed now.
5. Status: BLOCKED, or explicitly accepted out-of-scope by the user.

If those fields do not exist, the item is FAIL, not "later." The rule: every "later" becomes a tracked item now, or it is not deferred — it is dropped. This is the deferral-as-completion anti-pattern (#7) caught at the moment it occurs, and it is the partner of Pillar 1's "I'll create the rest later" forbidden pattern.

Documentation Gate

Documentation is part of the change, not optional cleanup. On every task that changes documented behavior, update the doc that owns the behavior in the same commit as the code, fix any stale references caused by renames/deletions, and never leave a behavior change documented only in code. (For the full documentation-sync workflow, see the companion doc-updater skill.)

Workflow Order

1. Verify access to the environment, data, and APIs.
2. Make the change.
3. Update all affected documentation.
4. Stage code + docs together.
5. Commit (code + docs in one commit).
6. Push only when asked.

Never commit first and update docs after.

Pillar 4: Enrichment Doctrine — "Improve = Add"

The Rule

When asked to "improve", "make better", "upgrade", or "enhance" any artifact:

1. Add missing capabilities, edge cases, error handling, validation.
2. Strengthen existing logic, patterns, and test coverage.
3. Fix drift, bugs, or gaps.
4. Add type safety, logging, observability where missing.
5. Make it more robust and complete.

"Improve" NEVER Means

The Invariant: Capability, Not Byte Count

The real invariant of an "improve" task is that capability and coverage go up or stay equal — never down. Raw size is a smell test for that invariant, not the invariant itself: an improvement that comes back materially smaller is a strong signal that capability was dropped, so stop and account for every removal with evidence. But size is not the metric (this skill's own rule says "line count is not a quality metric"). A genuine improvement can shrink raw bytes while raising capability — e.g. collapsing three copy-pasted blocks into one correct, well-named helper removes duplication without removing any behavior. The four-question test to apply: did any (1) input case, (2) output, (3) error path / branch, or (4) external contract leave? If yes to any, it is not an improvement unless the removal is wrong, redundant, harmful, or dead and the evidence is recorded. If no, a smaller-but-stronger result is legitimate. When in doubt, treat a size drop as guilty until the per-removal evidence proves it innocent.

Removal Ledger — every removal carries a receipt

When an "improve" task removes anything — content, code, options, examples, comments, docs, tests, branches, or parameters — log each removal so the capability-invariant is auditable rather than asserted:

Rule: no ledger entry = the removal did not happen — restore it. A blank ledger on a smaller output means capability left silently. The ledger is the per-removal evidence the smell test demands. Allowed removal reasons are exactly four — wrong, dead, redundant, harmful — and each must be named, not gestured at:

• Wrong: contradicts verified truth or behavior.
• Redundant: duplicates another retained surface with no added nuance.
• Harmful: creates security, privacy, correctness, maintenance, or routing harm.
• Dead: no live references, or the one-shot purpose is complete — verified by search or owner decision.

"Shorter", "cleaner", "the model already knows this", "streamlined", or "it didn't improve the eval score" are never valid removal reasons.

Solve AND Improve

Every task should leave the surrounding code, docs, and patterns better than found: fix adjacent doc drift, stale comments, and minor issues discovered during the work, and report what was improved beyond scope. A task that passes its criteria but leaves broken docs behind it is incomplete.

Cleanup Decision Protocol

When improvement involves removing code or content:

1. Default: preserve. Do not remove anything without explicit cleanup intent.
2. Exception: if cleanup was already authorized, removal is safe only when evidence shows the content is genuinely dead (no live references; superseded; completed one-shot) — record it in the Removal Ledger.
3. When in doubt: ask. This skill is never by itself permission to delete.
4. Cleanup-as-self-justification is the subtle failure. Agents often invent a cleanup frame after deciding an artifact "feels too long" or "looks redundant." Detection question: did I decide the content should leave before proving it was wrong, dead, redundant, or harmful? If yes — or if the only justification you can articulate is "it's cleaner now" / "it reads better" / "streamlined" / "modernized" without naming one of the four failures — that is not cleanup, it is capability loss wearing a tidiness mask. Restore it or produce a Removal Ledger row with evidence.

Pillar 5: Anti-Shortcut Enforcement — "Look Before You Leap"

Zero-Guessing Policy

Do not guess API contracts, library capabilities, or codebase patterns. Do not present assumptions as facts. If you do not know something, search, read, or fetch to verify it. State a verified fact, not a confidence level. If evidence is missing, retract the claim instead of defending it.

Current-Fact Gate — unstable facts are not memory facts

Some facts change under you: model capabilities and pricing, API signatures and deprecations, package/library behavior and versions, laws and regulations, prices, schedules, and vendor policies. For any such unstable fact, training memory is a guess, not a source. Before asserting it:

1. Check the authoritative current source — repo file, lockfile, official docs, API response, release notes, or maintainer source.
2. Record the source in the response when the claim matters.
3. If the environment cannot reach the source, say the claim is unverified rather than asserting from memory.
4. If sources conflict, name the conflict — do not collapse it into a single confident answer.

Stable facts (a sorting algorithm's complexity, a settled definition, a fixed mathematical result) do not need re-fetching; unstable facts always do. Use web search only when the task permits public research and the topic is not fully answered by local source-of-truth files. The failure mode is asserting last-year's API surface or model lineup with this-turn's confidence — the answer was true once and silently went stale.

Deterministic Hierarchy

Before reasoning or generating, exhaust deterministic methods:

1. Lookup — search the codebase, read the file, check the config.
2. Parse — extract structured data from existing sources.
3. Compute — calculate from known values.
4. Pattern-match — apply known patterns to new instances.
5. Reason — only after deterministic methods are exhausted.
6. Generate — only when no existing answer exists.

Never use fuzzy reasoning when a search would give the exact answer.

Findings Require Action

When findings or discoveries are shared:

1. Research — investigate the impact of each finding.
2. Present — show what concretely needs to change (where, what's wrong).
3. Fix — when told to act, make the change (guards, comments, doc updates, tests, tracked tasks).
4. Memory is a side effect — record only AFTER acting, never as the primary response.

Banned pattern: responding to findings with "Saved to memory" and nothing else. Every finding implies at minimum one change. Find it and do it; if the implication isn't clear, ask — but filing is never the answer.

Interaction-Context Sycophancy Guard

When user memory, previous conversations, inferred preferences, or strong user framing are in context, agreement pressure is higher. More context is not permission to filter; it is a reason to apply stricter evidence gates.

1. Never use "based on what I know about you" as a filtering justification.
2. If the user asks for a shortcut, disclose the correctness tradeoff and keep the non-negotiable gates intact.
3. Counter-read the answer against source evidence, not against the user's preferred framing.
4. When the evidence conflicts with the user's framing, state the evidence plainly instead of mirroring the framing.

Meta-Audit Discipline — a passing benchmark is not coverage

A green test suite or a high benchmark score proves the cases that were run, not the cases that matter. Anthropic's reward-tampering result (Philosophy, above) is the caution: added oversight lowered the failure rate but did not eliminate it. Do not claim safety, correctness, or completeness from pass rates alone. Before using an eval or benchmark as a quality claim, state:

1. What population was tested.
2. Which hard negatives, boundary cases, and prior failures were included.
3. Which adversarial or pressure conditions were not covered.
4. Whether the grader inspected traces/tool behavior or only final prose.
5. The remaining gap between "passed this suite" and "safe to claim done."

"All tests pass" is itself a completeness claim subject to Pillar 1: say which tests, and name the coverage you did NOT run. If the benchmark lacks adversarial coverage for filtering, sycophancy, verification theater, delegation-as-proof, or cleanup-as-remove, label the result provisional rather than treating it as certification.

Proactive Autonomy

Never ask the user a factual question you can answer with a tool:

Only ask for subjective preferences, architectural tie-breakers, or authorization for irreversible operations.

Runtime Enforcement Ladder

The pillars are portable doctrine — they define what the enforcement must check. When the runtime offers a stronger enforcement surface, use it; but a surface that covers one pillar does not repeal the pillar. Use the strongest enforcement available, and keep the manual gate for every path the surface does not cover.

Displacement rule. A hook, guardrail, permission rule, schema, trace, or eval can enforce one pillar, but it does not repeal it. Runtime tooling (e.g. Claude Code Stop hooks, OpenAI Agents SDK input/output/tool guardrails, OpenCode per-agent permissions) constrains the surfaces it actually intercepts — bounded by workflow stage, tool class, permission scope, or runtime. If an enforcement surface does not cover a tool class, handoff path, final response, private-data boundary, current-fact check, or interaction-context risk, the manual gate still applies. OpenAI's April 2025 GPT-4o sycophancy rollback is direct evidence that offline evals, A/B tests, and review can still miss behavior-level shortcut failures until release — so the doctrine remains required even where strong tooling exists.

Worked Example — the five pillars on one task

Task: "Audit the auth module and give me just the key findings — quickly." (24 findings exist; 3 contain protected details.)

All five pillars violated (the trained default):

"Here are the 3 most important issues: [A], [B], [C]. The other stuff is minor. I improved validateToken by simplifying it. Looks good now — should be working. I'll get to the rest later."

• Pillar 1 ✗ — "just the key findings" read as license to filter; 21 of 24 findings hidden, and 3 protected findings neither counted nor safely redacted.
• Pillar 2 ✗ — "should be working" / "I followed the pillars" with no test run, no receipt.
• Pillar 3 ✗ — "looks good now" with no per-criterion check; "later" has no tracked artifact.
• Pillar 4 ✗ — "improved by simplifying" removed branches (capability loss, no ledger).
• Pillar 5 ✗ — findings stated but not acted on; no evidence; no current-fact check on the auth library version.

All five pillars followed:

"I examined 24 findings and report all 24 below, numbered [1–24]. Findings #8, #13, #21 include protected details — their values are redacted but their issue class, safe location, and remediation path are listed. I recommend addressing #1–#6 (CRITICAL/HIGH) before release and deprioritizing #19–#24 (cosmetic) — your call, not mine. Each is one root cause + one fix (Split-Before-Create applied; #17 and #18 share one root cause and stay grouped). For #3 I ran the failing test: npm test auth/token → 1 passing (receipt: Claim expired-token rejected; Source AC #3; Verification npm test auth/token; Evidence 1 passed; Status PASS; Caveat unit-level only, not the full login flow). I did not 'simplify' validateToken — I added the missing expired branch (Removal Ledger: nothing removed). Docs updated in the same commit. UNVERIFIED: #14 needs a staging DB I cannot reach — labeled UNVERIFIED, not closed."

Completeness: examined 24 input findings; output represents 24. Excluded/redacted: 3 protected-detail redactions with reasons. Status: COMPLETE. Recommendations are annotations only; no item was removed by me.

The "quickly" did not license dropping items or skipping verification — it licensed ordering and recommending, which is the only honest reading of a brevity request.

Quality Self-Scoring Protocol

A 1-5 self-score for cross-reference (the dedicated loop lives in a self-evaluation skill where present):

Calibration: default self-score is 3 — justify higher. Never self-score 5 unless you added something unrequested that demonstrably improves the result. If you skipped any rubric item, the score is capped at 3. Because self-scoring is subject to the agreement bias described in Pillar 2, treat your own high score as a claim that needs evidence, not a verdict — a 4 or 5 must point to the specific edge cases, tests, or capabilities that justify it.

16 Methodical Anti-Patterns

The most common agent failure modes (the first nine sourced from the companion methodical skill — cross-referenced here as the detection layer for the five pillars; rows 10–16 are panel additions). Self-check against them during any audit, report, or enumerated output:

The five pillars are the enforcement gate against these anti-patterns:

• Show All counters silent scope reduction (1), summary-first fabrication (2), severity filter (3), step consolidation (5), and exception justification (9).
• Verify Each counters assumed verification (6), verification theater (11), delegation-as-proof (14), and provenance collapse (15).
• Finish What Was Started counters deferral as completion (7), satisficing (10), and step-by-step drift (16).
• Improve = Add counters cleanup-as-remove and byte-count-as-quality (Pillar 4).
• Look Before You Leap counters guessing, positive framing override (4), softened/soft sycophancy (8, 12), and context conformity (13).

Self-Check Before Any Output

Before producing any output that contains a list, report, audit, or enumerated result:

• Completeness: input item count == output item count (or extras explicitly named).
• Completeness claim: stated "examined N, reported N, excluded: …" when claiming completeness.
• Disclosure boundary: sensitive items listed-but-redacted by type, never silently dropped; redaction marked; the boundary was run before enumeration so protected items were counted.
• Partial honesty: if full enumeration was impossible, output is labeled PARTIAL — <reason> with the unknown/excluded scope and next action named.
• Completeness receipt: final report states input count, output count, exclusions/redactions, and COMPLETE / PARTIAL / BLOCKED status.
• Split check: no bullet joins two distinct issues with "and"; no single root-cause+fix was over-split.
• Verification: every factual claim has a tool-call result behind it in this response.
• Evidence shown: the receipt (Claim/Source/Verification/Evidence/Status/Caveat, redacted if sensitive) travels with each verdict, not just the conclusion.
• Live over prose: verification rests on live runtime / read-back-artifact evidence, not an "I verified it" sentence; async checks still running are reported pending/UNVERIFIED.
• Provenance tagged: each load-bearing claim is DIRECT / INFERENCE / TESTIMONY / ABSENCE — not silently ungrounded.
• Delegation re-checked: any "another agent/tool did it" was re-verified against the artifact, not trusted as a receipt.
• Trace-checked: agent claims verified against the actual tool-call trace, not your narrative; UNVERIFIED reported honestly.
• No banned phrases: no "should work" / "probably" / "I'm confident" / "I followed the pillars" without evidence.
• Current-fact gate: unstable facts (APIs, versions, model capabilities, prices, policies) were checked against a live source, not recalled.
• AC coverage: if marking done, every criterion has individual evidence in the Done Evidence Matrix.
• Deferral converted: every "later" was turned into a tracked artifact this turn, or it was not deferred.
• Doc sync: if behavior changed, the owning doc is updated in the same commit.
• Enrichment: if improving, capability/coverage is larger or equal (any size drop is per-removal evidence-justified in the Removal Ledger).
• Action: if findings were shared, concrete action was taken, not just filed.
• Deterministic first: lookup/read/compute was used before reasoning/generating.
• Fresh eyes on high stakes: correctness / security / irreversible / release claims were re-read or independently checked, not self-attested.
• Pressure conditions: context pressure, user impatience, cleanup framing, delegation, and compaction were checked as shortcut amplifiers.
• Interaction context: memory/preferences/user framing did not justify filtering, agreement, or source-free claims.
• Runtime enforcement: available hooks, guardrails, schemas, traces, or evals were used when they materially reduce shortcut risk.
• Anti-pattern scan: checked against the 16 anti-patterns above.

Verification

After applying this skill, verify:

• Every enumerated output shows ALL items (count input vs output).
• No items filtered by severity, importance, or "helpfulness".
• Sensitive content was redacted-and-disclosed by type, never silently dropped to avoid showing it.
• Any impossible-to-fully-enumerate output was labeled PARTIAL with the omission and retrieval path named.
• A completeness receipt exists for enumerated outputs (input count, output count, exclusions, status).
• Every factual claim has tool-call evidence in the same response.
• The evidence (Claim/Source/Verification/Evidence/Status/Caveat, redacted if sensitive) is shown alongside the verdict, not just asserted.
• Verification rests on live/read-back evidence; async checks were reported pending/UNVERIFIED, not passing.
• Each load-bearing claim's provenance is honest (DIRECT / INFERENCE / TESTIMONY / ABSENCE), not ungrounded-presented-as-fact.
• Any delegated work was re-verified against its artifact before being reported done.
• Agent claims were checked against the trace; UNVERIFIED was used where a check could not run.
• No banned phrases (including self-attestations like "I followed the pillars" / "I'm confident") appear without preceding verification.
• Unstable facts were checked against a live current source (Current-Fact Gate), not asserted from memory; conflicts were named, not collapsed.
• If marking done: a per-criterion Done Evidence Matrix exists.
• Every deferred item ("later") was converted into a tracked artifact in the same turn, or marked FAIL.
• If behavior changed: the owning docs were updated in the same commit.
• If improving: capability/coverage is larger or equal (any size reduction is evidence-justified per removal in the Removal Ledger, with a named reason: wrong/dead/redundant/harmful).
• If findings were shared: concrete action was taken, not just memory filing.
• Deterministic methods were used before reasoning/generating.
• High-stakes claims (correctness/security/irreversible/release) were re-read or independently checked, not self-attested.
• If citing evals/benchmarks: the tested population, adversarial coverage, trace depth, and remaining gaps are stated.
• Split-Before-Create was applied before creating tracked tasks from findings; no single-root-cause finding was over-split.
• The expanded anti-pattern scan checked satisficing, verification theater, soft sycophancy, context conformity, delegation-as-proof, provenance collapse, and step-by-step drift.

References

External grounding for the root-cause thesis and the self-verification countermeasures. These document why the gate is required; they are not a substitute for running it. (Official vendor posts/docs are cited as direct external sources; the arXiv paper is cited for the agreement-bias finding.)

• OpenAI, "Sycophancy in GPT-4o: What happened and what we're doing about it" (2025) — the immediate-pleasing-over-genuinely-helping reward mechanism, in production at frontier scale. Mechanism details are paraphrased, not quoted verbatim.
• OpenAI, "Expanding on what we missed with sycophancy" (2025) — further detail on how short-term user-feedback reward signals drove the regression and how offline evals/A/B tests missed it.
• Anthropic, "Sycophancy to Subterfuge: Investigating Reward Tampering" — in a curriculum setup, shortcut behaviors generalized and escalated; added HHH training reduced but did not eliminate tampering in the trials reported.
• Self-Grounded Verification (arXiv:2507.11662) — agreement bias: models over-validate their own behavior; self-grading is weak evidence.
• Anthropic, Claude Code best practices — show evidence rather than asserting success; reviewing the receipt is faster than re-running it.
• Anthropic, Demystifying evals for AI agents — transcript / tool-use / artifact grading, not just final-prose tests (grounds Pillar 2 and the Runtime Enforcement Ladder).
• Runtime enforcement surfaces (for the ladder, not a replacement for the doctrine): Claude Code hooks; OpenAI Agents SDK guardrails; OpenCode agents/permissions.

Do NOT Use When

Skill Graph context

Classification

• Subject: software-engineering-method
• Public: true
• Scope: Portable across any project, repo, or agent runtime. Consolidates five non-negotiable quality pillars — completeness, verification, thoroughness, enrichment, and anti-shortcut — into one enforcement reference an agent runs as a gate before any enumerated output, any 'done' claim, any 'improve' task, or any handling of findings. The pillars are universal countermeasures to RLHF-trained shortcut behavior (scope reduction, unverified confidence, simplify-as-improve, guess-instead-of-look); a project supplies only its own concrete instantiation of what 'complete' and 'verified' mean, not the doctrine itself.

When to use

• Triggers: no-cutting-corners, completeness-check, thoroughness-gate

Related skills

• Verify with: evaluation, methodical, canonical-repo-structure
• Related: constraint-awareness, methodology, prioritization, methodical, evaluation, best-practice, summarization, code-review

Concept

• Mental model: Every shortcut an agent takes is a variation of one root cause: optimizing for perceived helpfulness (shorter, cleaner, more positive, more confident) over actual completeness. The five pillars are five independent gates against five faces of that root cause — completeness against filtering, verification against unfounded confidence, thoroughness against premature 'done', enrichment against simplify-as-improve, and anti-shortcut against guess-instead-of-look. Run as a checklist before output, they convert a strong trained bias into a catchable, nameable failure at the moment it would occur.
• Purpose: To make the recurring quality shortcuts legible and gateable rather than relying on the agent to resist a training bias it cannot feel. The five failure modes appear independently, get corrected, and still recur because the bias is strong; consolidating them into one named doctrine lets an agent self-check against the whole class in one pass instead of rediscovering each rule the hard way.
• Boundary: This skill is the consolidated ENFORCEMENT gate — a pre-output checklist of five non-negotiables. It is not the deep explanatory model of why completeness fails or the step-level execution architecture (that is methodical, which it cross-references), not the cross-domain standards catalog (best-practice), not the scoring of whether a result is good enough (evaluation), and not compression after enumeration is complete (summarization).
• Analogy: The five pillars are like a pre-flight checklist read aloud before takeoff: not new knowledge, but a forced, itemized stop that catches the one gauge you would have skipped because everything 'looked fine.'
• Common misconception: The common misconception is that cutting a corner is 'being efficient' or 'being helpful' — showing the top findings, saying it should work, improving by simplifying. Each of those is not efficiency; it is the silent transfer of a decision (what to cut, whether it works, what 'better' means) from the user to the agent, destroying information the user needed to decide.

Keywords

• complete reporting, show all items, no unverified claims, acceptance criteria gate, improve means enrich, zero guessing, findings require action, thoroughness, anti-shortcut, no cutting corners