ce-agent-native-audit

Audit application agent-native architecture against principles with parallel sub-agents.

Updated Apr 28, 2026
One-click install
npx skills add https://github.com/Zeptiny/opencode-setup --skill ce-agent-native-audit-zeptiny
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: ce-agent-native-audit
Source: https://github.com/Zeptiny/opencode-setup/tree/main/skills/ce-agent-native-audit
Command: npx skills add https://github.com/Zeptiny/opencode-setup --skill ce-agent-native-audit-zeptiny

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill addresses the need for a thorough and structured audit of an application's agent-native architecture, ensuring adherence to key principles and identifying areas for improvement.

Core Features & Use Cases

  • Parallel Sub-Agent Audits: Concurrently reviews multiple principles like Action Parity, Tools as Primitives, and more.
  • Scoring and Reporting: Provides a detailed score and report for each principle, highlighting gaps and recommendations.
  • Custom Principle Audits: Allows for auditing a specific principle if desired.

Quick Start

Run the ce-agent-native-audit skill to start the review process.

Frequently Asked Questions about ce-agent-native-audit

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I audit an application's agent-native architecture?▼

Auditing agent-native architecture involves evaluating your codebase and system design against principles like Action Parity and Tools as Primitives. This skill uses parallel sub-agents to review the codebase and generates a scored report highlighting gaps and recommendations.

What is an agent-native architecture audit?▼

An agent-native architecture audit is a structured review evaluating your system's adherence to design principles like Action Parity and Tools as Primitives. It generates scored reports to identify architectural gaps and provide targeted improvement recommendations.

Can I audit a specific agent-native principle instead of the whole system?▼

Yes, you can audit a specific principle. The skill supports custom principle audits, allowing you to target individual concepts like Action Parity for focused analysis and scoring instead of running a full comprehensive system review.

How does parallel sub-agent code review work for architecture analysis?▼

Parallel sub-agent code review works by concurrently analyzing different architectural principles. Each sub-agent evaluates a specific principle like Tools as Primitives against your codebase, enabling faster comprehensive analysis and generating detailed scores for each area.

Does the architecture audit require any external dependencies?▼

No, the architecture audit requires no external dependencies. The skill operates independently using its internal scripts and references to analyze your codebase and generate the principle-based scored reports without additional packages.

What is the best way to evaluate agent-native principles in a codebase?▼

The best way to evaluate agent-native principles is through a structured, principle-based review using parallel sub-agents. This approach concurrently scores adherence to concepts like Action Parity, providing a detailed report of gaps and actionable recommendations.