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.