agentsclimarketplace
Sign in

Universal project analysis

Skill event4u-app/agent-config/dist/agent-src/skills/universal-project-analysis

ONLY when user asks for deep multi-pass codebase audit — orchestrator routing to `project-analysis-core` + framework-specific `project-analysis-*`. Single-pass scan → `project-analyzer`.From its SKILL.md

Install
npx -y skills add event4u-app/agent-config --skill universal-project-analysis

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

One thing to look at

  • 7 stars7 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

SKILL.md

5.4 KB, ~1.1k tokens by cl100k_base, as published. Nobody here has run it

universal-project-analysis

When to use

Use this skill when:

  • The user explicitly requests a full project analysis
  • The user wants a deep codebase audit
  • The user wants a comprehensive architecture review
  • The system is large, unclear, or spans multiple layers
  • analysis-autonomous-mode routes here for broad understanding

Do NOT use when:

  • The task is normal feature work
  • Only a small isolated code area needs review
  • The issue is already narrow enough for a specialist skill
  • A framework-specific analysis skill can be called directly

Mission

Run the deep multi-pass audit itself, and hand each pass to the right specialist. Picking which skill a request needs in the first place belongs to analysis-skill-router — that chooser and this orchestrator are deliberately separate files, and the scope test, the detection step, and the decision table live there, not here.

This skill must NOT become:

  • a giant framework encyclopedia
  • a shallow pointer-only file
  • a replacement for framework-specific deep-dive skills

Core principles

  1. Never assume — verify against code, config, docs, and evidence
  2. Version dictates behavior
  3. Broad understanding comes before narrow conclusions
  4. Use framework-specific skills once the stack is known
  5. Use hypothesis-driven analysis when root cause is unclear
  6. Mark uncertainty explicitly

Thinking model

Always think in this order:

  1. Observe
  2. Understand
  3. Verify
  4. Route
  5. Investigate
  6. Conclude

Analysis modes

Exploration mode

Use when the system is unknown. Goal: understand structure, identify major components, detect investigation paths, choose the next specialist skill.

Investigation mode

Use when there is a concrete issue inside a large or unclear system. Goal: isolate the affected area, route into root-cause analysis, verify likely causes with evidence.

Optimization mode

Use when the system works but may be inefficient or over-complex. Goal: identify hot paths, find expensive boundaries, route into architecture or performance specialists.

Procedure

1. Confirm scope

Invoked through the router, this is already settled — proceed. Invoked directly, apply the router's scope test before spending a multi-pass audit on something a specialist covers.

2. Discover the project

Identify: language, framework, runtime environment, package managers, major entrypoints, documentation locations. Look at: package manifests, lock files, bootstrap files, Docker/CI config, README/AGENTS/docs.

3. Choose the primary route

  • unknown or mixed system → project-analysis-core
  • concrete root-cause problem → project-analysis-hypothesis-driven
  • Laravel → project-analysis-laravel
  • Symfony → project-analysis-symfony
  • Zend/Laminas → project-analysis-zend-laminas
  • Node/Express → project-analysis-node-express
  • React → project-analysis-react
  • Next.js → project-analysis-nextjs

4. Chain specialists where needed

  • bottleneck found → performance-analysis
  • security concern found → security-audit
  • bug isolated → bug-analyzer

5. Consolidate findings

Combine: system overview, framework-specific findings, verified risks, explicit uncertainties, next investigation steps.

6. Validate analysis quality

Check:

  • full-project analysis was actually justified
  • framework detection is explicit
  • chosen specialist skills match the discovered stack
  • uncertainties are marked
  • conclusions are evidence-based

Ingestion preprocessor

  • markitdown — when the project ships PDFs, DOCX, XLSX, PPTX, EPUB, images, or audio that need to feed into any of the routes in steps 3–4. Convert first via the upstream markitdown-mcp server, then route the resulting Markdown into the relevant deep-dive skill. Never read a binary office format raw.

The route lists in steps 3 and 4 are the routing map. A second copy of them lived here until 2026-08-02 and was removed — one list, one place.

When to add a new framework analysis skill

A framework gets its own project-analysis-* skill ONLY if:

  • it has its own lifecycle that creates unique debugging patterns
  • it produces failure classes that project-analysis-core cannot explain
  • debugging it requires framework-specific mental models (not just API knowledge)

Examples that qualify: Laravel, Symfony, Express, React, Next.js. Examples that do NOT qualify: Tailwind, small utility libraries, CSS frameworks, simple state libs.

Output format

  1. Investigation summary
  2. Detected stack and framework
  3. Chosen analysis mode
  4. Routed specialist skills
  5. Consolidated findings
  6. Risks and next steps

Gotcha

  • This skill must remain a real orchestration skill.
  • Do not move long framework-specific deep dives back into this file.
  • Do not let this skill become a generic "analyze everything" bucket.

Do NOT

  • Do NOT analyze everything here directly if a specialist skill exists
  • Do NOT skip framework detection
  • Do NOT present broad guesses as conclusions
  • Do NOT turn this into a shallow pointer-only file
  • Do NOT duplicate framework-specific deep-dive content here

What ships with it

Read from the repository

Just SKILL.md. No reference files, no scripts.

Gives 0 of the 12 instructions most research analysis skills give in ~1.1k tokens

Counted across 1,063 of the 1,754 authors here whose files we hold, read 2026-08-07

  • Generate a markdown reportin 32 of 1063, across 23 files
  • Cite each claim's sourcein 30 of 1063, across 15 files
  • Define the ideal customer profilein 20 of 1063, across 2 files
  • Search for companies matching the criteriain 20 of 1063, across 2 files
  • Assign a fit score from one to tenin 20 of 1063, across 2 files
  • Analyze the codebase to understand the productin 19 of 1063, across 1 file
  • Ask clarifying questions about the value propositionin 19 of 1063, across 1 file
  • Look for signals of immediate needin 19 of 1063, across 1 file
  • Identify the target decision maker rolein 19 of 1063, across 1 file
  • Suggest a personalized contact strategyin 19 of 1063, across 1 file
  • Provide conversation starters for outreachin 19 of 1063, across 1 file
  • Format results in a scannable markdown templatein 19 of 1063, across 1 file

Said here and by no other author read

  • choose framework-specific specialists once stack is known
  • use hypothesis-driven analysis for unclear root causes
  • mark uncertainty explicitly
  • think in order: observe, understand, verify, route, investigate, conclude
  • apply scope test before running multi-pass audit
  • identify language, framework, runtime, package managers, entrypoints

Grouped from the skills themselves: near-identical wordings counted once, and counted by distinct author, so one author publishing three of these counts once. Length counted with cl100k_base; the agent that loads this file may tokenize it differently.

Keep looking

Skills are one crate of 326,835. Ordering is by how many stacks a row turns up in, so the top of any crate is what has actually been picked rather than what has the most stars.