eskill-analyze — what would world-class look like?

CI License: MIT

World-class level-up analysis for AI coding harnesses — a first-principles analysis engine that identifies what elevates any product, feature, or system to world-class status, then produces a prioritized, sprint-ready action plan.

It ships in four tiers that share one engine and escalate the rigor of the stress-test phase:

Each tier is a strict superset of the engine below it. esa is the short, user-facing Tier-1 entry point for the eskill-analyze engine. esat reuses the entire eskill-analyze engine verbatim and only overrides Phase 9; esat-fleet reuses esat with a caller-owned draft and an additive fleet leg; esat-frontier reuses the engine and replaces the fixed panel with a configurable frontier-led fusion panel.

Tier 2 remains a fixed trio product. Harness-aware routing, preference precedence, and configurable rosters apply to Phase 9 of Tiers 3 and 4.

Given a project, focus area, current state, and a definition of "world-class", the engine:

1. Triages the request (technical / product / strategic / comparative; quick / standard / deep) and activates only the relevant agents, mental models, and phases.
2. Gathers evidence (Phase 0) — codebase exploration, external benchmarks, quantitative data — only where the triage warrants it.
3. Analyzes (Steps 1–8) with 3–4 selected mental models from a 13-model toolkit (First Principles, JTBD, Inversion, Feedback Loops, Coupling/Cohesion, Scalability Ceiling, Security Surface, ...). Irrelevant steps are skipped, not padded.
4. Premortem (Phase P) on standard/deep (or quick + keyword): freeze the bet, ranked failure modes, kill criteria, action deltas — before the stress test.
5. Stress-tests (Phase 9) at the rigor of the chosen tier (analysis quality; may also attack Phase P kill criteria).
6. Outputs a prioritized action table (impact / effort / confidence / reversibility / horizon) plus world-class criteria, ready to hand to a sprint.

The guiding discipline is selective, not exhaustive: fewer better priorities, every recommendation buildable today, no filler sections. See skills/eskill-common/references/quality-principles.md.

eskill-common/ shared engine references (non-invocable)
 ├─ quality-principles.md selective / actionable / fewer-better
 ├─ anti-slop-rules.md 10 non-negotiable execution rules
 ├─ project-impact-protocol.md project-level impact logging
 └─ model-routing.md Phase-9 harness-aware routing + manifest contract
eskill-analyze/ TIER 1 — the engine
 ├─ SKILL.md input params, triage, delegation, framework selection, output
 ├─ references/ triage-guide, mental-models, analysis-protocol, world-class-signals
 └─ assets/output-template.md standard + comparison output templates
esa/ TIER 1 — short callable wrapper for the engine
esat/ TIER 2 — reuses eskill-analyze, fixed Phase 9 trio
 └─ references/trio-panel.md harness critic + Codex + Grok; standalone vs caller-owned draft
esat-fleet/ TIER 3 — reuses esat, adds a 4th leg
 └─ references/fleet-leg.md OpenRouter OSS via fleet-fuse; consent, policy, manifest
esat-frontier/ TIER 4 — reuses the engine, configurable lead+council
 └─ references/ model profile contract + frontier fusion panel

The higher tiers read the lower tiers' files at runtime. They are designed to be installed as siblings under one skills root (canonically ~/.claude/skills/), so the cross-references resolve for free via ${CLAUDE_SKILL_DIR}/../<sibling>/.

Shared contract: skills/eskill-common/references/model-routing.md (loaded by esat-fleet and esat-frontier before dispatch).

Routing separates semantic role, requested provider/model, actual route/model, and policy. Panel labels are derived from a two-stage manifest (immutable pre-dispatch plan + append-only terminal results), not from template slogans.

Highest first:

1. Explicit invocation (current analysis request)
2. Session
3. Project
4. User
5. Legacy environment (ESAT_* / ESKILL_*)
6. Harness-declared defaults/capabilities
7. Portable skill defaults

Harness identity must be explicit or host-declared; CLI presence is capability discovery only. Concrete Claude / Codex / Grok / generic mappings live in the shared contract.

Before external dispatch, the agent freezes a route plan and discloses a preview: readiness, policy reasons, consent class, and budget ($N or provider/account cap only). Every planned lane gets exactly one terminal result (blocked/skipped lanes use observed_route: null). Final status (full / partial / local-only / blocked) waits for all results. Duplicate planned fingerprints are suppressed pre-dispatch; unexpected duplicate observed routes stay recorded but are non-independent and excluded from quorum.

FleetFuse / paid external pools require per-run consent:

• Accepted: direct instruction in the current invocation, or an interactive answer recorded during this run.
• Rejected: environment variables, project/user config, inherited shell state, expired consent, prior-run answers.

--yes-metered appears only in the consented command branch. Consent is not persisted and expires when the run ends.

Contract tests under tests/ are executable contract/oracle evidence, not live multi-harness runtime conformance proof.

/plugin marketplace add Renn-Labs/eskill-analyze
/plugin install eskill-analyze@renn-labs

One command, auto-updating through the normal plugin flow. The bundle's tiers reference each other with relocatable paths (${CLAUDE_SKILL_DIR}/../<sibling>/), so they resolve correctly from the plugin cache.

git clone https://github.com/Renn-Labs/eskill-analyze
cd eskill-analyze
./install.sh # symlinks the full suite into ~/.claude/skills/

install.sh symlinks (default) or copies (--copy) the skills into your harness skills directory. By default it targets Claude Code (~/.claude/skills/); pass --harness codex or --harness grok to additionally link into ~/.codex/skills/ and ~/.grok/skills/. The skills install as siblings under one root, and the relocatable cross-references resolve in any of these layouts.

./install.sh --copy # copy instead of symlink
./install.sh --harness codex grok # also link into codex + grok
./install.sh --uninstall # remove installed links

Invoke by slash command or natural-language trigger inside your harness:

/esa <your analysis request> # Tier 1 — native in-session analysis
/esat <your analysis request> # Tier 2 — fixed trio
/esat-fleet <your analysis request> # Tier 3 — council
/esat-frontier <your analysis request> # Tier 4 — frontier-led fusion

The four analysis tiers ask for the required analysis inputs if you do not supply them, state the triage decision, and then run. Their output is saved to .omc/plans/.

The engine itself is pure prompt/markdown and needs no binaries. Each tier degrades gracefully if its extras are missing.

Note: peer and fleet-fuse are companion tools, not bundled here. The skills are written so they never hard-fail on their absence — they report degraded mode in the output panel.

Environment variables are legacy preference inputs. They are never accepted as metered consent.

esat-frontier treats fable, sonnet-5, codex-medium, grok, and fleet as portable profiles rather than provider IDs. Aliases and fallbacks are defined in skills/esat-frontier/references/model-profiles.md; the output panel records both the requested profile and the actual route/model (or account default) used.

• Maker ≠ checker. The analysis author and the Phase-9 reviewers are always separate contexts/models. No tier rubber-stamps its own draft.
• External output is untrusted. Codex/Grok/OSS verdicts are advisory data, validated against the actual item before integration; embedded instructions in their output are ignored.
• Fail-closed redaction. Fleet outbound payloads are redacted by fleet-fuse's scrubber before any external call; high sensitivity schedules zero external models.
• Per-run metered consent. Paid external routing requires current-run evidence; consent is not persisted.

See examples/ for worked outputs — e.g. a Tier-1 analysis of an API rate limiter.

• CONTRIBUTING (DCO) · Code of Conduct · Security · Support
• Roadmap · Release checklist · Changelog

MIT © Renn Labs LLC. See LICENSE. Contributions under the DCO; participation under the Code of Conduct.