version: "1.0.0" name: agent-native-audit description: Run a comprehensive scored audit of agent-native architecture principles model: claude-sonnet-4.6 platforms: copilot: model: gpt-5.3-codex opencode: model: openrouter/moonshotai/kimi-k2.6 argument-hint: "[optional: specific principle to audit]" disable-model-invocation: true

Agent-Native Audit

Run a comprehensive review of a codebase against agent-native architecture principles, split the work into scored principle-specific audit tracks, and produce a prioritized summary report.

Announce at start: "I'm using the agent-native-audit skill to run a scored agent-native architecture review."

When to Use

• After adding agent tools, prompts, commands, or shared-workspace behavior
• Before shipping major agent-facing product changes
• When you need a numeric baseline for how agent-native a system really is
• When you want prioritized recommendations instead of a vague architectural opinion

Core Principles to Audit

1. Action Parity - "Whatever the user can do, the agent can do"
2. Tools as Primitives - "Tools provide capability, not behavior"
3. Context Injection - "System prompt includes dynamic context about app state"
4. Shared Workspace - "Agent and user work in the same data space"
5. CRUD Completeness - "Every important entity has full CRUD (Create, Read, Update, Delete)"
6. UI Integration - "Agent actions are reflected in the product experience"
7. Capability Discovery - "Users can discover what the agent can do"
8. Prompt-Native Features - "Features are prompts defining outcomes, not rigid workflow code"

Workflow

Step 1: Load the Local Reference Skill

First, invoke agent-native-architecture to refresh the local vocabulary, principles, checklist, and anti-patterns used in this plugin.

Focus especially on:

• Core principles
• Architecture Review Checklist
• Tool Design
• Files & Workspace
• Context Injection
• UI Integration
• Capability Discovery
• Anti-Patterns

Use the local skill name directly. Do not rely on Every-specific namespaced invocations.

Step 2: Decide Audit Scope

If $ARGUMENTS names a single principle, audit only that principle.

Otherwise, audit all 8 principles.

When auditing a plugin, CLI, or developer-tooling codebase, map "user actions" and "UI" broadly:

• Slash commands
• Prompts
• Agents
• Skills
• CLI entrypoints
• Generated artifacts
• Shared files, docs, and workspace state

Step 3: Launch Parallel Audit Tracks

Launch up to 8 parallel audit tracks using the platform's task/subagent tool.

• On Claude-style platforms, this is typically Task with subagent_type
• On Copilot-style platforms, this is typically task with agent_type

Prefer discovery-oriented agents for evidence gathering and stronger review agents for synthesis when available. In this plugin, agent-native-reviewer, architecture-strategist, explore, and general-purpose are all reasonable choices depending on platform and available agents.

Each audit track should:

1. Enumerate all relevant instances in the codebase
2. Check compliance against the principle
3. Produce a specific numeric score in X/Y format
4. List concrete gaps
5. Recommend the highest-impact fixes first

Audit Track Prompts

Track 1: Action Parity

Audit for ACTION PARITY - "Whatever the user can do, the agent can do."

Tasks:

1. Enumerate all meaningful user actions across product surfaces:

• UI actions
• Slash commands
• CLI actions
• Form submissions
• API endpoints
• File and workspace operations

1. Check which actions have corresponding agent tools, commands, or capabilities
2. Score: "Agent can do X out of Y user actions"

Format:

## Action Parity Audit
### User Actions Found
| Action | Location | Agent Equivalent | Status |
|--------|----------|------------------|--------|
### Score: X/Y (percentage%)
### Missing Agent Capabilities
### Recommendations

Track 2: Tools as Primitives

Audit for TOOLS AS PRIMITIVES - "Tools provide capability, not behavior."

Tasks:

1. Find and read all agent tools, commands, or callable integration surfaces
2. Classify each as:

• PRIMITIVE (good) - Exposes a capability without embedding decision-making
• WORKFLOW (risky) - Encodes business logic, orchestration, or branching that should live in prompts

1. Score: "X out of Y tools are proper primitives"

Format:

## Tools as Primitives Audit
### Tool Analysis
| Surface | File | Type | Reasoning |
|---------|------|------|-----------|
### Score: X/Y (percentage%)
### Workflow-Heavy Surfaces
### Recommendations

Track 3: Context Injection

Audit for CONTEXT INJECTION - "System prompt includes dynamic context about app state."

Tasks:

1. Find context injection code, system prompts, and agent setup logic
2. Enumerate what is injected versus what should be injected:

• Available resources
• User preferences
• Recent activity
• Workspace or session state
• Available capabilities
• Relevant history

1. Score: "X out of Y important context categories are injected"

Format:

## Context Injection Audit
### Context Types Analysis
| Context Type | Injected? | Location | Notes |
|--------------|-----------|----------|-------|
### Score: X/Y (percentage%)
### Missing Context
### Recommendations

Track 4: Shared Workspace

Audit for SHARED WORKSPACE - "Agent and user work in the same data space."

Tasks:

1. Identify all important data stores and shared artifacts:

• Files
• Databases
• Documents
• Session stores
• Queues
• Generated outputs

1. Check whether agents and users operate on the same state or separate shadow state
2. Score: "X out of Y important data spaces are truly shared"

Format:

## Shared Workspace Audit
### Data Space Analysis
| Data Space | User Access | Agent Access | Shared? |
|------------|-------------|--------------|---------|
### Score: X/Y (percentage%)
### Isolated State (anti-pattern)
### Recommendations

Track 5: CRUD Completeness

Audit for CRUD COMPLETENESS - "Every important entity has full CRUD."

Tasks:

1. Identify all important entities, resources, or managed objects
2. For each, check whether the agent can:

• Create
• Read
• Update
• Delete

1. Score per entity and overall

Format:

## CRUD Completeness Audit
### Entity CRUD Analysis
| Entity | Create | Read | Update | Delete | Score |
|--------|--------|------|--------|--------|-------|
### Overall Score: X/Y entities with full CRUD (percentage%)
### Incomplete Entities
### Recommendations

Track 6: UI Integration

Audit for UI INTEGRATION - "Agent actions are reflected in the product experience."

Tasks:

1. Check how agent actions propagate to user-visible surfaces
2. Look for:

• Immediate UI refresh
• Shared state updates
• Eventing or streaming
• File watching
• Regeneration steps
• Clear feedback in CLI or docs

1. Identify silent-action anti-patterns where the agent changes something but the user cannot see it promptly

Format:

## UI Integration Audit
### Agent Action -> User Visibility Analysis
| Agent Action | Surface Update Mechanism | Immediate? | Notes |
|--------------|--------------------------|------------|-------|
### Score: X/Y (percentage%)
### Silent Actions
### Recommendations

Track 7: Capability Discovery

Audit for CAPABILITY DISCOVERY - "Users can discover what the agent can do."

Tasks:

1. Check for these discovery mechanisms:

• Onboarding or getting-started guidance
• Help documentation
• Capability hints in UI or command descriptions
• Agent self-description
• Suggested prompts or workflows
• Empty-state guidance
• Slash commands or discoverable command lists

1. Score against the mechanisms that are relevant to the product

Format:

## Capability Discovery Audit
### Discovery Mechanism Analysis
| Mechanism | Exists? | Location | Quality |
|-----------|---------|----------|---------|
### Score: X/Y (percentage%)
### Missing Discovery Paths
### Recommendations

Track 8: Prompt-Native Features

Audit for PROMPT-NATIVE FEATURES - "Features are prompts defining outcomes, not code."

Tasks:

1. Read prompts, agents, skills, commands, and orchestration code
2. Classify each important behavior as defined primarily in:

• PROMPT (good) - Outcome described in natural language
• CODE (risky) - Business logic hardcoded in conditionals or rigid orchestration

1. Check whether changing behavior usually requires prompt edits or code edits

Format:

## Prompt-Native Features Audit
### Feature Definition Analysis
| Feature | Defined In | Type | Notes |
|---------|------------|------|-------|
### Score: X/Y (percentage%)
### Code-Defined Behaviors
### Recommendations

Step 4: Compile the Summary Report

After all audit tracks finish, compile a single report:

## Agent-Native Architecture Review: [Project Name]
 
### Overall Score Summary
 
| Core Principle | Score | Percentage | Status |
|----------------|-------|------------|--------|
| Action Parity | X/Y | Z% | ✅/⚠️/❌ |
| Tools as Primitives | X/Y | Z% | ✅/⚠️/❌ |
| Context Injection | X/Y | Z% | ✅/⚠️/❌ |
| Shared Workspace | X/Y | Z% | ✅/⚠️/❌ |
| CRUD Completeness | X/Y | Z% | ✅/⚠️/❌ |
| UI Integration | X/Y | Z% | ✅/⚠️/❌ |
| Capability Discovery | X/Y | Z% | ✅/⚠️/❌ |
| Prompt-Native Features | X/Y | Z% | ✅/⚠️/❌ |
 
**Overall Agent-Native Score: X%**
 
### Status Legend
-✅ Excellent (80%+)
-⚠️ Partial (50-79%)
-❌ Needs Work (<50%)
 
### Top 10 Recommendations by Impact
 
| Priority | Action | Principle | Effort |
|----------|--------|-----------|--------|
 
### What's Working Excellently
 
[List top 5 strengths]

Success Criteria

• [ ] All requested audit tracks complete
• [ ] Each principle has a specific numeric score in X/Y format
• [ ] Summary table includes all audited principles and status indicators
• [ ] Recommendations are prioritized by impact
• [ ] Report identifies both strengths and gaps

Optional: Single Principle Audit

If $ARGUMENTS specifies a single principle, run only that audit track and provide detailed findings for that principle.

Valid arguments:

• action parity or 1
• tools or primitives or 2
• context or injection or 3
• shared or workspace or 4
• crud or 5
• ui or integration or 6
• discovery or 7
• prompt or features or 8