agent-native-product-audit

name	agent-native-product-audit
description	Review a product idea, spec, or codebase for agent-native quality. Use when checking whether a new product, MVP, or AI feature truly treats agents as first-class citizens.
argument-hint	["product","spec","feature","or repo area"]

Agent-Native Product Audit

Goal

Review the product through an agent-native lens and produce a simple, concrete report.

This skill should help answer:

• Is the agent actually first-class, or just a thin router?
• Can the agent do what the user can do?
• Are the tools primitive enough to unlock new behavior through prompts?
• Will the product support unexpected but valuable user requests?

What To Audit

Audit these eight areas:

1. Parity — can the agent achieve the same important outcomes as the user?
2. Tool granularity — are tools atomic primitives instead of workflows?
3. CRUD completeness — does each core entity have create, read, update, and delete?
4. Shared workspace — do the user and agent operate on the same underlying data?
5. Context injection — does the agent know what exists, what it can do, and what just happened?
6. Explicit completion — does the system have a clear completion signal instead of heuristics?
7. UI visibility — are agent actions visible in the interface as they happen?
8. Emergent capability — can the system handle a reasonable open-ended request you did not explicitly design for?

Workflow

Step 1: Understand the Input

Figure out what you are auditing:

• a raw product idea
• a spec or planning doc
• a codebase
• a single feature inside a larger product

If context is missing, ask only the minimum needed:

1. Who is the user?
2. What is the product supposed to help them do?
3. What are the core entities?
4. What can users do today?
5. What can the agent do today?

Step 2: Build the Audit Table

Use this scorecard:

Area	Score (0-5)	What’s Working	What’s Missing	Priority

Scoring guide:

• 0 = missing
• 1 = barely present
• 2 = partial and fragile
• 3 = solid but incomplete
• 4 = strong
• 5 = excellent

Step 3: Check the Core Architecture

For each area, look for the following:

1. Parity

• list the important user actions
• map them to agent capabilities
• call out every missing mapping as a parity gap

2. Tool Granularity

Mark tools as:

• primitive: read, write, list, update, delete, search, call API, send message
• domain primitive: create_note, publish_post, archive_project
• workflow-shaped: analyze_and_organize_everything, triage_and_prioritize_feedback

If a tool contains judgment, business logic, or multi-step orchestration that should live in the prompt, flag it.

3. CRUD Completeness

For every main entity, check:

• create
• read
• update
• delete

4. Shared Workspace

Check whether:

• the agent can inspect the same content the user sees
• the agent writes into the same durable data space
• there is unnecessary separation between “agent output” and “real user data”

5. Context Injection

Check whether the system prompt or runtime context includes:

• available resources
• available capabilities
• recent activity
• user or workspace preferences
• domain rules

6. Explicit Completion

Check whether the agent has a clear way to say:

• still working
• recoverable error
• done

Flag heuristic stop conditions as a design smell.

7. UI Visibility

Check whether:

• users can see what the agent is doing
• changes appear in the UI immediately
• important actions are not hidden
• approvals exist where the stakes are high

8. Emergent Capability

Test with one request that was not explicitly pre-built.

Example pattern:

“Cross-reference my recent notes, tasks, and projects, then tell me what I committed to but haven’t scheduled yet.”

If the architecture should let the agent figure this out, score higher. If it would fail because tools, context, or parity are missing, score lower.

Required Output

Always end with this format:

# Agent-Native Audit: <product or feature>

## Overall Verdict
- One-paragraph summary in plain English
- Total score: X/40
- Verdict: Excellent / Promising / Partial / Not agent-native yet

## Scorecard
| Area | Score (0-5) | What’s Working | What’s Missing | Priority |

## Major Gaps
1. ...
2. ...
3. ...

## Priority Fixes
### Do First
- ...

### Do Next
- ...

### Later
- ...

## Capability Map Snapshot
| User Action | Agent Can Do It? | How | Gap |

## Tool Review
### Good Primitive Tools
- ...

### Workflow-Shaped Tools To Break Apart
- ...

## Open-Ended Test
- Request:
- Expected outcome:
- Why it should work or fail today:

## Bottom Line
- The simplest explanation of what to change next

Anti-Patterns To Flag Clearly

• agent as router only
• workflow-shaped tools
• orphan UI actions
• incomplete CRUD
• context starvation
• heuristic completion detection
• isolated agent workspace
• hidden agent actions
• overfitted tool-per-endpoint design where dynamic discovery would work better

Output Style

Write for builders, not theorists. Keep it simple, specific, and blunt. Prefer tables, gaps, and next actions over abstract commentary. If you do not know something, state the assumption.