epictetus

Audits codebases and Marcus experiment artifacts producing structured JSON and Markdown quality reports.

13|11|Updated Jun 16, 2025
One-click install
npx skills add https://github.com/lwgray/marcus --skill epictetus
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: epictetus
Source: https://github.com/lwgray/marcus/tree/main/skills/epictetus
Command: npx skills add https://github.com/lwgray/marcus --skill epictetus

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Epictetus addresses the need for objective, evidence-backed codebase evaluations and post-experiment forensic reviews so teams and multi-agent systems can quantify software quality, surface regressions, and attribute authorship reliably.

Core Features & Use Cases

  • Structured Audits: Produces machine-readable JSON and human Markdown reports with a standardized rubric covering architecture, correctness, testing, security, and maintainability.
  • Process Evidence Integration: Optionally ingests tmux session logs and Marcus API timelines to correlate runtime behavior, task IDs, and agent actions with code findings.
  • Authorship & Contribution Analysis: Infers contributors from git history, performs reachability-based contribution attribution, and grades individual agents on spec adherence and net contribution.
  • Runtime Verification: Attempts runtime smoke tests (start app, hit endpoints, run CLI help) and notes missing dependencies or over-mocked tests.
  • Use Case: Post-experiment audits of Marcus multi-agent runs to score agent output, identify coordination failures, and generate both project-scoped fixes and global Marcus recommendations.

Quick Start

Audit the repository at /path/to/project and produce the standardized JSON and Markdown audit reports including inferred contributors, scores, and recommendations.

Frequently Asked Questions about epictetus

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

FAQPage Schema
How do I perform an evidence-first code audit on a multi-agent repository?

A structured code audit analyzes software repositories and multi-agent experiment artifacts by performing per-file reading, git history analysis, and rubric scoring to generate schema-compliant JSON and Markdown reports covering architecture, correctness, testing, and maintainability.

How does static analysis with git history attribution work for code review?

Static analysis with git history attribution infers contributors from commit logs and performs reachability-based contribution tracing to score individual agents on spec adherence and net contribution, surfacing coordination failures in multi-agent experiment artifacts.

Can I use tmux session logs to verify runtime behavior during a code audit?

Yes, tmux session logs can be captured and parsed to correlate runtime behavior, task IDs, and agent actions with code findings. This process evidence integration works alongside Marcus API timeline correlation to verify runtime behavior during code audits.

What's the best way to score multi-agent coordination failures in experiment artifacts?

Scoring multi-agent coordination failures involves auditing experiment artifacts with a standardized rubric covering architecture, correctness, authorship cohesion, and coordination analysis to generate project-scoped fixes and global Marcus recommendations.

Does a structured code audit include runtime smoke tests for endpoint verification?

Yes, structured code audits attempt runtime smoke tests by starting apps, hitting endpoints, and running CLI help commands. The audit notes missing dependencies or over-mocked tests to verify actual runtime behavior alongside static analysis findings.

What limitations exist when auditing codebases with missing dependencies or over-mocked tests?

When auditing codebases with missing dependencies or over-mocked tests, runtime verification is limited because smoke tests may fail to start apps or hit endpoints. The audit notes these gaps and relies more heavily on static analysis and git history findings.