Arguments. [skills|agents|hooks|output-styles|claude-md|rules|all]. default: all
Purpose
The official prompting guide prescribes posture guidance that agentic components should CARRY:
delegation criteria, scope guardrails, grounding instructions, autonomy postures, confirmation
gates. audit-instructions detects instruction text that is present and wrong; this skill detects
text that is absent and needed. It classifies each component by purpose, checks the postures that
purpose calls for, and proposes additions with wording taken from a live fetch of the guide, never
from this file.
Read-only contract
Report-only. No --fix: every proposed addition is applied by the human (or explicitly delegated
afterward). A clean audit is a valid outcome, and with well-authored components it is the expected
one. The default verdict per posture is NOT-APPLICABLE, not MISSING.
Instruction-held, not tool-enforced. Never tell an operator this skill cannot edit their files.
disallowed-tools: Edit, NotebookEdit narrows the surface, nothing more: Write stays in the tool
set for Phase D's report file and Phase B has already read every audited component, so it can overwrite one; Bash stays for
Phase D's persist script, and a shell mutates files too. That closes the likeliest accidental path, not the
capability, and a skill auditing assurance must not overstate its own. We treat the restriction as
clearing on the human's next message, so whoever accepts a proposal can apply it (Pointer: when
deciding how long the restriction lasts, fetch
skills: frontmatter reference live.
As of: 2026-10-11. Recheck trigger: that section or a release note changes how long
disallowed-tools lasts).
Scope boundary (route out)
- Text that is present and wrong, covering over-prescription, stale claims, emphasis language and
retired parameters, is
audit-instructions. When one sweep wants both lanes, run both skills; a coordinated pass (audit-pass, when installed) composes them. - Structural skill lint is
skill-quality:check; token brevity isdocs-hygiene:compress. - Upstream-owned surfaces (installed plugin cache, managed materializations) produce routing
recommendations to the owning repository, never in-place proposals, the same exclusion
audit-instructionsapplies.
Phase A: Fetch the guide
The posture catalog in reference/postures.md carries, per posture, an applicability predicate and a POINTER to the guide section that states the recommended wording. It carries no copied sample text, so no proposal is written before the page it cites is in hand. It names two kinds of page, fetched at different times and failing differently.
The best-practices page: fetched here, every run, before any judging. It is this skill's one
non-negotiable input: nearly every posture points at it. If it cannot be fetched,
ABORT the run, naming the URL and the failure; continuing would emit a catalog of
wording-unverified postures, a report shaped like an audit that audited nothing. Same posture the sibling takes on its
own single input (audit-instructions/SKILL.md, "Fail loud on ambiguity").
Model-specific subpages and the usage guide: fetched lazily, in Phase C, per applicable row,
when a posture whose predicate matched points at one, not once per catalog row, since a row names
its subpage whether or not anything in scope matches. A failed subpage fetch degrades only the
postures citing it: mark those wording-unverified, carry the pointer instead of wording, never
invent text. One page is fatal; the rest are local, and "before judging anything" does not mean
holding every page at once.
Phase B: Inventory and classify
Parse $ARGUMENTS for an optional scope filter (skills, agents, hooks, output-styles,
claude-md, rules, or all, the default). It narrows which surfaces may produce findings, never
which pages Phase A fetches.
Enumerate locally-owned instruction components in scope. This skill names its own surface set;
it shares the resolution procedure with audit-instructions Phase A, not the list. Resolve
${CLAUDE_CONFIG_DIR:-~/.claude} and project .claude/, and apply the same liveness and
upstream-ownership exclusions. The set, one entry per scope token above: skill bodies (and the
context/reference files a skill instructs the model to read), agent definition markdown, hook
instruction text of both kinds, output-style markdown, CLAUDE.md / a natively read AGENTS.md or
.claude/AGENTS.md / CLAUDE.local.md, .claude/rules/. Whether an AGENTS.md is read natively
depends on whether AGENTS.md support is available in the session and on the instruction-files mode, and this body does not
restate the condition: the four-part record for both questions is this plugin's
reference/agents-md-liveness.md; resolve it there, not from
a copy that can drift. The set follows the effective mode, not the default mode's answer: an
AGENTS.md beside a CLAUDE.md belongs in the set whenever the effective mode loads it. The record
says which scopes honor the setting; resolve the effective value across them, not one scope's
copy, which answers the wrong question whichever way the override runs.
The mode is the second question, not the only one, and either can rule the file out. Availability
comes first and is not a mode question: a session where support is unavailable, for a reason the
liveness record lists, reads no AGENTS.md under ANY mode, and inventorying one would let Phase C
propose posture additions to a surface nothing loads. No hooks setting is among those reasons. A
mode that loads no AGENTS.md rules it out the same way. Exclude on a condition
known to rule it out; most are readable, so resolve before falling back.
Where a condition stays unresolved, inventory the file but carry the doubt into the finding.
Phase C judges every inventoried component and emits a MISSING posture for it, so silently
including a surface of unknown residency proposes work on a file the session may not load. Any
posture finding anchored on such an AGENTS.md is emitted NOT-APPLICABLE with the unresolved
condition as its failed predicate, the verdict the closed token set below reserves for a predicate
that did not hold. That keeps the surface in the report without asserting a gap the reader cannot
act on. Only where the file is genuinely not read does it reach context as an import, which the
importing record already covers.
- Pointer: when deciding which files a mode loads, fetch memory: choose which instruction files load live. As of: 2026-11-03. Recheck trigger: that section adds, removes or changes a mode.
The inventory bounds what may produce a finding, not what counts as evidence. Phase C's mechanical-gate rule reads outside it to establish PRESENCE, which can only turn a MISSING into a PRESENT, never add a finding on an excluded surface.
For each component, classify its purpose from its own description and body. The classification vocabulary and its tie to each posture's predicate live in the catalog. A component can match several purposes or none; none is the common case, and unclassified components go in the coverage line, never force-fitted.
Phase C: Judge postures
For each component × applicable posture: does the component (or a file it instructs the model to read) already carry the posture, in any wording? Judge substance, not phrasing. A numeric concurrency cap satisfies the delegation-criteria posture without quoting the guide. Only a genuine absence on a component whose purpose clearly needs it becomes a finding. Three standing fences:
- Do not manufacture. The predicate must match the component's actual purpose, not a conceivable use. When in doubt, NOT-APPLICABLE.
- Mechanical gates are presence evidence and do not live in the inventory. P7, and only P7,
blesses a deny-by-default hook or script gate "without any prose", while Phase B inventories
instruction text, so those gates sit outside that set. Before judging a
destructive-capablecomponent MISSING on P7, look in all three: settings scopes Phase B resolved (permissions.deny/ask), hook config registering a PreToolUse matcher over the action, and the script the component delegates the action to, following the invocation and reading it, since a component whose destructive step runs through a script that performs the approval check is gated. Any one of the three is PRESENT, cited by file and rule, or by script and line. - Repo conventions win on wording. The proposal adapts the guide's substance to the component's own voice and the repo's terseness conventions; it never pastes a guide block verbatim into a proposal without trimming to what the component needs.
Phase D: Verify and report
Dispatch one fresh-context, non-fork verifier per surface batch, prompted to refute each proposed
addition: "argue this component's purpose does not need this posture, or that it already carries
it." A refuted finding is demoted to info and kept, never dropped. It stays a row carrying its
refutation, because deleting it erases the evidence that Phase D ran and disagreed.
A run with no proposed addition still runs Phase D, on the verdicts. Refuting proposals can only
remove findings, so on a clean run the same verifier is prompted the other way: "argue that a
component needs a posture it was judged not to need, that its purpose classification is wrong, or
that a PRESENT citation does not carry the posture." Each reversal becomes a row with its
corrected verdict and the verifier's argument; a reversal to MISSING carries its proposed addition
like any other finding. A clean audit is reported clean only after this check.
Verification level. Before Phase D, run bash "${CLAUDE_PLUGIN_ROOT}/lib/read-verification.sh" --plugin harness-config --skill audit-prompting-postures
and copy its line into the report header (levels).
standard and strict are the two paragraphs above. Under light, and off, which acts as
light here, dispatch no Phase D verifier, on proposals or on verdicts, and never refute inline
in its place: follow "When dispatch is unavailable" below with the reason
verification: skipped (<level>), and a run with no proposed addition is reported unverified,
never clean.
When dispatch is unavailable
Phase D requires fresh-context, non-fork verifier dispatch. When the Agent tool is blocked, unavailable, or the session cannot spawn subagents:
- Disclose in the report header that Phase D did not run and why.
- Mark unverified proposals. Every proposed addition that did not receive an independent
verifier carries an
(unverified)marker and is never presented as a confident finding. - The verifier attestation line at the report tail says Phase D did not run, and names the surface batches verified inline or skipped.
Persist the report to ${CLAUDE_PLUGIN_DATA}/audit-prompting-postures/<state-key>/last-audit.md.
Write the report with the Write tool first, to a scratch file outside the plugin data directory
and outside every audited component (a file under the session's temporary directory), so the
report passes the Write tool's content guards like every other file this skill writes. Then
persist it by running this script on that file; the script derives <state-key>, creates the
directory and writes last-audit.md atomically, then prints the path it wrote:
bash "${CLAUDE_PLUGIN_ROOT}/lib/persist-report.sh" \
--plugin-data "${CLAUDE_PLUGIN_DATA}" --component audit-prompting-postures --report <report-file>
--report - (the body on stdin) is the fallback for a session where the Write tool is unavailable,
never the main route. Pass the data directory as the --plugin-data argument shown, never through
the environment. Persist only through this script: never run a standalone mkdir, or any command
of your own, against the plugin data directory. (Pointer: when deciding where ${CLAUDE_PLUGIN_DATA}
resolves, fetch
plugins manifest reference: where each variable resolves
live; for why an inline command against the data directory is avoided, read the eval-trace
evidence in #12039. As of: 2026-11-01. Recheck trigger: that section changes which environments
receive ${CLAUDE_PLUGIN_DATA}, or a later eval trace shows an inline command against the data
directory running undenied.)
We key the report per project because one data directory serves every project on the machine, so
a fixed last-audit.md would be silently overwritten by the next run from any other root, this
skill's only durable deliverable, destroyed by ordinary use of it (Pointer: when deciding the data
directory's scope, fetch
plugins manifest reference: environment variables
live. As of: 2026-11-10. Recheck trigger: that section makes the data directory per project). The scheme is <repo-identity>/<worktree-discriminator>, defined by the
marketplace's plugin-data-report-keying convention and reused rather than reinvented, and it
lives in one executable rather than being restated per skill,
lib/state-key.sh, with lib/state-key.test.sh beside it, which the
persist script runs. Run bash "${CLAUDE_PLUGIN_ROOT}/lib/state-key.sh" --explain when the report
should say which rung produced the key. The key stops overwrites, not reaping.
An uninstall can delete the plugin's data directory, so when a report must outlive the plugin the
closing line says to copy it out of the data directory (Pointer: when deciding whether a report
survives an uninstall, fetch
plugins CLI reference: what an uninstall deletes and keeps
live. As of: 2026-10-11. Recheck trigger: that section or a release note changes what uninstalling
does with ${CLAUDE_PLUGIN_DATA}).
Let the script derive the key. Do not express the path as a condition over ${CLAUDE_PROJECT_DIR}
"when set": where that placeholder is substituted (pointer below) makes the condition not yours
to evaluate. Derive the key from a command you run.
- Pointer: when deciding where a skill placeholder is substituted, fetch skills: available string substitutions live.
- As of: 2026-10-11
- Recheck trigger: that section changes where or when
${CLAUDE_PROJECT_DIR}is substituted.
Open the report with a three-line header, so a file that survives is self-describing:
Resolved root: <absolute path audited>
Scope filter: <the scope argument this run used, or "all">
Run (UTC): <ISO-8601 timestamp>
Then summarize in chat:
| # | Posture | Component | Verdict | Proposed addition or pointer |
|---|
Verdicts are a closed set of four tokens: MISSING (finding, with proposed addition as a fenced diff),
PRESENT (where it is), NOT-APPLICABLE (with the failed predicate), info (a Phase D verifier
refuted it, always kept as a row, never dropped, never a proposal to apply). Two markers are
orthogonal and ride alongside a verdict, never in place of one: wording-unverified (a subpage
fetch failed in Phase C, so the fifth column carries the guide POINTER, and a pointer is never
dressed up as guide wording) and (unverified) (Phase D could
not verify this proposal; see "When dispatch is unavailable"). End with a coverage line naming components
inventoried, classified and unclassified, and a Sources line citing the pages fetched this run with
dates. End every run with a verifier attestation line naming the surface batches verified, verified
inline, or skipped, and which check the verifier ran on each: proposals or verdicts.
Gotchas
- Presence can live one file away. A SKILL.md that routes to a context file the model must read counts as carrying whatever that file carries. Follow the component's own read instructions before judging absence.
- Human-gated designs are not missing autonomy postures. A report-only skill that ends at a human gate needs no autonomous-pipeline branch; the autonomy posture applies to components that claim unattended operation.
- Model-conditional postures stay conditional. Where the guide ties a posture to specific models, the proposal must be model-neutral or carry the same condition, since components here run on any consumer model.
What this skill does NOT do
- Never edits a component and never auto-applies a proposal. This is held by instruction, since
disallowed-toolsnarrows the surface butWriteandBashremain and both can mutate a file. - Never copies guide text into its own catalog; wording comes from the run's live fetch.
- Does not judge existing text (that is
audit-instructions), lint structure (skill-quality:check), or compress prose (docs-hygiene:compress).