Skip to main content
skill CX Codex

owner-intent-audit — Claude Code skill: review and install

The owner-intent-audit Claude Code skill checks plans, tests, and code against the project owner’s intent. Run it before approving or merging agent work.

Apache-2.0 ★ 869 updated 2026-11-16

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add sno-ai/sno-station-skills --skill owner-intent-audit -a claude-code
Open on GitHub

What owner-intent-audit does

The skill checks whether an agent’s plan or code preserves the requested outcome and flags work added beyond the request. It looks for lost requirements, unnecessary scope, outdated claims, unreachable decision branches, and completion claims without proof. Plan mode covers specifications and task lists; code mode covers agent-written changes, tests, and subsystems.

The review follows an ordinary user flow, compares the artifact with the current contract and project state, then traces an entry point to an observable result. In code mode, it runs less-is-more in cut mode; agentic-walkthrough is used when installed. File read/write and shell execution are required.

Assessing intent requires the original request, the complete Q&A record, and settled decisions. Missing or stale evidence produces an incomplete-evidence verdict for intent, while the other checks still run. This review does not replace a separate review for bugs or security issues.

What it helps with

  • catch requirements lost while drafting a plan
  • spot scope added by an agent
  • find claims that no longer match project state
  • check whether decision branches can run and completion has proof

Example prompts for the agent

  • Audit this plan against my request and the decisions we settled.
  • Review these changes before merging; flag missing requirements and added scope.
  • Trace the ordinary flow to its result and check the evidence for claimed work.

How to install owner-intent-audit

1Skills CLI (Vercel)

npx skills add sno-ai/sno-station-skills --skill owner-intent-audit -a claude-code

2Manually: put the files in place

~/.claude/skills/owner-intent-audit/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/owner-intent-audit/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about owner-intent-audit

How do I install owner-intent-audit in Claude Code?

Run npx skills add sno-ai/sno-station-skills --skill owner-intent-audit -a claude-code. The skill file is at ~/.claude/skills/owner-intent-audit/SKILL.md.

What does owner-intent-audit do?

It compares an agent’s plan or code with the project owner’s intent, looking for lost meaning, unrequested work, and completion claims without evidence. Bug and security review remain separate.

What does owner-intent-audit need to assess intent?

It needs the original request, the full question-and-answer record, and settled decisions. File read/write and shell execution are required; code mode also uses less-is-more.

Source text

SKILL.md · Apache-2.0
---
name: owner-intent-audit
description: "Check agent-produced plans, tests, or code against the owner's actual intent. Find missing meaning, unrequested work, stale truth, unreachable decisions, unsupported completion claims, and implementation debt. Use before approval or merge."
requires:
  programs: []
  harness:
    - {slot: 4.shell, need: required}
    - {slot: 4.file-read-write, need: required}
---

# Owner Intent Audit

The question this review answers is not "is the artifact good" but **"is this what the owner
meant, and what did the agent leave behind while making it?"** (The owner is whoever owns the
work and decides what it should be; often that is the user.) An agent can produce a PRD (product
requirements document), a plan, or a diff that is locally excellent and still specify a different product, carry work
nobody asked for, or hide the debts agents characteristically create. Reviewing the artifact
for its own defects — bugs, security holes, silent death — is peer-review's job, not this one;
the two are run separately and neither substitutes for the other.

- **Plan mode:** PRDs, designs, specs, task lists, refactor plans, and test plans.
- **Code mode:** diffs, files, tests, or subsystems substantially written by agents.

Start with the ordinary user and system flow. Realistic common-path failure outranks exotic
edge cases.

## What must be established

### 0. Did the artifact preserve the product meaning?

This is not “did every source bullet appear?” A locally plausible artifact can retain the
same nouns while specifying a different product.

Determine:

- who needs the outcome and who decides;
- what result they actually need;
- when the behavior applies and when it must not;
- which exceptions, prohibitions, priorities, and trade-offs matter;
- how separate answers constrain or explain each other;
- what observable result distinguishes success from an easier proxy.

Find that meaning in the owner's raw request, the complete question-and-answer record, and the
settled decisions. If the project keeps no such record, say so and use `incomplete-evidence`.
Find loss of meaning in the target's requirements, ordinary flow, boundaries,
design choices, and acceptance criteria. In code mode, also look through the governing
contract (the spec, interface, or acceptance text the code is supposed to satisfy), callers, state changes, and user-visible result.

Important shapes include a condition becoming unconditional, an actor changing, an example
becoming the whole boundary, a prohibition disappearing, related answers becoming isolated
facts, or a familiar implementation replacing the requested outcome.

Keyword overlap and row-count traceability are not proof. Return real ambiguity to the owner;
do not invent meaning.

### 1. What did the agent over-build?

Run the `less-is-more` skill in cut mode on the diff (code mode). In plan mode, apply its cut
list to the plan as a checklist: what is proposed that the owner did not ask for, and what could
be deleted without losing the requested outcome. Every item it reports is a finding here. In plan mode, also ask what wording would invite
a literal agent to build it. Work that is necessary but belongs in a runbook, an orchestration
step, or a test harness rather than the product contract is misplaced process work: report where
it should move, without dropping its constraint.

### 2. Does the artifact graph resolve to one identity?

The plan or spec and everything tied to it must name the same current artifact by path, hash, and
status, and every referenced file must exist. For example, where the project has them: a PRD, its
acceptance file, its test commands, its evidence, and its status header. A stale identity or an
unreachable verifier is a finding. Validate an absence check with a known positive control.

### 3. What is current truth?

Separate **current contract** (what must be delivered), **current state** (what ran, passed, or
remains), and **historical narrative** (why it changed). History may explain current truth; it
cannot override it. A load-bearing claim that no longer matches reality — in a PRD, plan,
comment, default, or completed task — is a finding, because it misleads the next agent.

### 4. Is the decision model executable?

Check decision tables, state machines, ordered guards, schemas, fixtures, and tests. Every
claimed branch must be reachable, branches claimed as exclusive must not overlap, and duplicate
or shadowed branches must not masquerade as distinct outcomes.

### 5. Did claimed work run and reach its consumer?

“Ran,” “wired,” “enabled,” “deployed,” or “passed” require effect proof, not a flag, log line,
or clean exit. Trace the ordinary entrypoint to an observable result; run the
`agentic-walkthrough` skill when it is installed.

## Evidence and judgment boundaries

Owner-intent preservation needs the raw request, complete Q&A, and settled decisions. Missing,
partial, stale, or non-blind intent evidence means `incomplete-evidence`, not `clean`; it limits
only the semantic verdict, and every other check still runs and reports. Intent evidence is
non-blind when the reviewer had already read the artifact under review before reconstructing the
owner's meaning, so the comparison is not independent; say so.

A behavior finding needs a realistic trigger and a material consequence; test it against
guards and reachability before keeping it. An over-build finding from `less-is-more` needs no
trigger: the extra code is the consequence. Do not report style debt.

## Output

By default this audit is one judgment pass: do not rerun it, or run another model review, to
confirm the edits that follow it; a project may choose otherwise. Never write a `clean` verdict
before the audit has run. Keep the actual report immutable, record how each finding was handled,
fix the material blockers in the work under review, prove the fixes deterministically, and
continue without a model confirmation review (unless the project requires one).

```markdown
## Owner Intent Audit — <target>
Mode: plan | code
Verdict: clean | findings | incomplete-evidence
### Semantic preservation
Owner-intent status: preserved | findings | not-assessable | non-blind
Contract-conformance status: preserved | findings | not-assessable
Evidence: <what supports the judgment and what is missing>
### Over-built
<the less-is-more cut output, plus any misplaced process work, or "Lean already.">
### Findings
[critical|high|medium] <finding> — <location>
Scenario: <realistic trigger and concrete consequence; omit for over-build>
Correction: <smallest outcome that removes the risk>
### Guardrails
<plan mode only; concise outcome constraints for the implementing agent>
```

`clean` requires every check, adequate intent evidence, and no unresolved material blocker in the
work under review—not zero raw findings. Resolved findings and non-blocking debt never force another review.

© sno-ai · Apache-2.0 · sno-ai/sno-station-skills

Similar skills

SKILL.md skills catalog →

From the same set40

The whole set →
test-writer test-writer — a skill for Claude Code writes and improves test code. It activates when Codex is asked to add or change tests. CX Codex +1 ★ 869repo stars shellscript-coder shellscript-coder — a Claude Code skill for writing and refactoring shell scripts and command-line tools. It applies to automation, Git helpers, and infrastructure tasks. CX Codex +1 ★ 869repo stars rust-coder The rust-coder Claude Code skill implements and refactors Rust code using the project’s own conventions. It activates for feature work, migrations, and substantial edits to .rs files or Cargo.toml. CX Codex +1 ★ 869repo stars python-coder The python-coder skill for Claude Code guides Python implementation and refactoring, including work with FastAPI and Pydantic. It applies to async code and migration tasks. CX Codex +1 ★ 869repo stars less-is-more less-is-more — a skill for Claude Code that keeps code changes small and trims overbuilt solutions. It activates for coding, bug fixes, refactors, and diff reviews. CX Codex +1 ★ 869repo stars first-principles-review The first-principles-review Claude Code skill challenges product ideas, PRDs, and architecture using first-principles reasoning. It runs only when explicitly named and writes a local review with a PRD handoff. CX Codex +1 ★ 869repo stars e2e-red-triage The e2e-red-triage Claude Code skill classifies an unexpected end-to-end test failure as a product defect or an environment fault. Load it manually after the suite runner identifies a specific failure. CX Codex +1 ★ 869repo stars e2e-environment-preflight The e2e-environment-preflight Claude Code skill checks external dependencies before an end-to-end run. It loads only when named or in the specified planning and test-workflow situations. CX Codex +1 ★ 869repo stars

Project sponsors

Companies that keep this analytics open