Ce Agent Native Audit
Score your codebase against eight agent-native architecture principles with parallel audits before shipping agent-facing products.
Overview
ce-agent-native-audit is an agent skill most often used in Build (also Ship, Operate) that runs parallel sub-agent reviews and scores your codebase against eight agent-native architecture principles.
Install
npx skills add https://github.com/everyinc/compound-engineering-plugin --skill ce-agent-native-auditWhat is this skill?
- Audits 8 scored principles: action parity, tools-as-primitives, context injection, shared workspace, CRUD completeness,
- Workflow loads ce-agent-native-architecture reference then launches 8 parallel Explore sub-agents—one principle each
- Produces a consolidated scored report for gaps and remediation priorities
- disable-model-invocation: true—intended as an explicit slash-command audit, not ambient auto-invoke
- Optional argument-hint to focus audit on a single principle
- 8 core architecture principles audited
- 8 parallel sub-agents launched in the default workflow
Adoption & trust: 1.5k installs on skills.sh; 20.5k GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
You shipped agent features but lack a systematic way to measure action parity, CRUD completeness, and prompt-native design across the whole app.
Who is it for?
Teams with an existing agent-integrated app who want a repeatable architecture scorecard instead of ad-hoc opinions in chat.
Skip if: Greenfield projects with no code yet, or teams who only need a quick lint-style pass without the eight-principle framework and parallel deep dives.
When should I use this skill?
You need a comprehensive scored review of agent-native architecture and will explicitly run the audit command rather than ambient invocation.
What do I get? / Deliverables
You get a scored audit report with per-principle findings so you can prioritize refactors before scaling agent workflows or invoking follow-up implementation skills.
- Scored agent-native architecture report
- Per-principle findings from parallel audits
Recommended Skills
Journey fit
Spans multiple journey phases - primary shelf plus alternate fits below.
Canonical shelf is Build → agent-tooling because the skill evaluates how well the product exposes actions, tools, and context to coding agents. Subphase agent-tooling fits a structured architecture review of CRUD parity, tool primitives, and prompt-native features—not a one-off code review.
Where it fits
After adding agent tools, run the eight-principle audit to find missing delete/update paths on core entities.
Pre-release gate to confirm capability discovery and UI integration before customers rely on the agent.
Quarterly re-audit when new features added user-only flows the agent cannot mirror.
How it compares
Use instead of a generic code review when the goal is agent-native product architecture, not style or security alone.
Common Questions / FAQ
Who is ce-agent-native-audit for?
Solo and indie builders building agent-native SaaS or tools who need an explicit architecture audit before launch or major refactors.
When should I use ce-agent-native-audit?
During Build when tightening agent tooling; in Ship before release when agent UX must match user capabilities; in Operate when drift breaks action parity or UI sync after iterative changes.
Is ce-agent-native-audit safe to install?
Treat it like any third-party skill: review the Security Audits panel on this Prism page and confirm parallel sub-agents only explore code you intend to expose.
Workflow Chain
Requires first: ce agent native architecture
SKILL.md
READMESKILL.md - Ce Agent Native Audit
# Agent-Native Architecture Audit Conduct a comprehensive review of the codebase against agent-native architecture principles, launching parallel sub-agents for each principle and producing a scored report. ## 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 entity has full CRUD (Create, Read, Update, Delete)" 6. **UI Integration** - "Agent actions immediately reflected in UI" 7. **Capability Discovery** - "Users can discover what the agent can do" 8. **Prompt-Native Features** - "Features are prompts defining outcomes, not code" ## Workflow ### Step 1: Load the Agent-Native Skill First, invoke the agent-native-architecture skill to understand all principles: ``` /ce-agent-native-architecture ``` Select option 7 (action parity) to load the full reference material. ### Step 2: Launch Parallel Sub-Agents Launch 8 parallel sub-agents using the platform's subagent primitive (`Agent` with `subagent_type: Explore` in Claude Code, `spawn_agent` with `agent_type: "explorer"` in Codex, `subagent` with `agent: "scout"` in Pi via the `pi-subagents` extension), one for each principle. Each agent should: 1. Enumerate ALL instances in the codebase (user actions, tools, contexts, data stores, etc.) 2. Check compliance against the principle 3. Provide a SPECIFIC SCORE like "X out of Y (percentage%)" 4. List specific gaps and recommendations <sub-agents> **Agent 1: Action Parity** ``` Audit for ACTION PARITY - "Whatever the user can do, the agent can do." Tasks: 1. Enumerate ALL user actions in frontend (API calls, button clicks, form submissions) - Search for API service files, fetch calls, form handlers - Check routes and components for user interactions 2. Check which have corresponding agent tools - Search for agent tool definitions - Map user actions to agent capabilities 3. Score: "Agent can do X out of Y user actions" Format: ## Action Parity Audit ### User Actions Found | Action | Location | Agent Tool | Status | ### Score: X/Y (percentage%) ### Missing Agent Tools ### Recommendations ``` **Agent 2: Tools as Primitives** ``` Audit for TOOLS AS PRIMITIVES - "Tools provide capability, not behavior." Tasks: 1. Find and read ALL agent tool files 2. Classify each as: - PRIMITIVE (good): read, write, store, list - enables capability without business logic - WORKFLOW (bad): encodes business logic, makes decisions, orchestrates steps 3. Score: "X out of Y tools are proper primitives" Format: ## Tools as Primitives Audit ### Tool Analysis | Tool | File | Type | Reasoning | ### Score: X/Y (percentage%) ### Problematic Tools (workflows that should be primitives) ### Recommendations ``` **Agent 3: Context Injection** ``` Audit for CONTEXT INJECTION - "System prompt includes dynamic context about app state" Tasks: 1. Find context injection code (search for "context", "system prompt", "inject") 2. Read agent prompts and system messages 3. Enumerate what IS injected vs what SHOULD be: - Available resources (files, drafts, documents) - User preferences/settings - Recent activity - Available capabilities listed - Session history - Workspace state Format: ## Context Injection Audit ### Context Types Analysis | Context Type | Injected? | Location | Notes | ### Score: X/Y (percentage%) ### Missing Context ### Recommendations ``` **Agent 4: Shared Workspace** ``` Audit for SHARED WORKSPACE - "Agent and user work in the same data space" Tasks: 1. Identify all data stores/tables/models 2. Check