ontoly-software-graph
Helps your agent analyze software and trace requests. It uses a software graph to understand dependencies and the impact of changes.
What it does
This tool helps understand how a software project is organized and how its parts connect. It analyzes the code to create a detailed 'map' of the project.
When to use it
- ✓When you want to know the overall architecture of a project.
- ✓To understand the impact of changing a piece of code.
- ✓To trace how a request flows through different parts of the system.
Example of what to ask your AI
“Explain the architecture of this project.”
Want more? Open the sections below.
How to use
The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.
Skill link
Ready-to-paste message
How it works
The tool first checks if a project 'map' already exists. If not, it creates one by analyzing the code. Then, it uses this map to answer questions about the project.
Installation
Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.
In the terminal (Claude Code, Codex, Cursor), in your project folder:
npx skills add sickn33/agentic-awesome-skills --skill ontoly-software-graphOr download just the file:
curl -L https://raw.githubusercontent.com/sickn33/agentic-awesome-skills/main/plugins/agentic-awesome-skills-claude/skills/ontoly-software-graph/SKILL.md -o SKILL.mdTechnical content (original SKILL.md)
Original text by the author, straight from GitHub.
Ontoly Software Graph
Overview
Ontoly builds a deterministic Software Graph from a TypeScript repository and exposes it through CLI queries, MCP capabilities, and agent skills. Use this skill when a coding agent needs evidence-backed codebase understanding before searching files directly.
This skill is an operating guide for the public Ontoly project. It does not contain compiler logic; all software understanding should come from Ontoly's generated graph, semantic model, query engine, and MCP server.
When to Use This Skill
- Use when the user asks for repository architecture, module ownership, or onboarding help.
- Use when tracing a request, route, controller, service, provider, dependency, or call chain.
- Use when estimating impact for removing, renaming, or refactoring a symbol, module, package, route, or service.
- Use when reviewing dependency topology, circular imports, dead code, configuration usage, or environment variables.
- Use when the user explicitly wants Ontoly, Software Graph, MCP, graph validation, semantic coverage, or agent skills.
How It Works
Step 1: Verify Ontoly Is Available
Check whether the repository already has Ontoly outputs such as .ontoly/, SoftwareGraph.json, validation reports, or documented Ontoly scripts. If the ontoly command is unavailable, ask the user whether to install or use the repository's documented package manager command.
Recommended local checks:
ontoly --help
find . -maxdepth 3 \( -name "SoftwareGraph.json" -o -name ".ontoly" \) -print
Step 2: Build or Refresh the Graph
Only run a graph build in the repository the user asked about. Tell the user that graph generation may create local Ontoly artifacts before running it.
ontoly build .
If the project documents a different command, prefer the documented command over guessing.
Step 3: Check Trust, Diagnostics, and Coverage
Before answering architectural questions, inspect Ontoly diagnostics, graph statistics, trust, and semantic coverage. Treat unresolved imports, low trust, missing framework detection, or graph validation failures as answer constraints.
Use the CLI or MCP capabilities exposed by the installed Ontoly version. Prefer structured graph queries over text search.
Step 4: Use Ontoly MCP Capabilities
Start or connect to the Ontoly MCP server when the host supports MCP:
ontoly mcp
Use capabilities such as architecture summaries, dependency analysis, request tracing, impact analysis, configuration lookup, framework reports, dead-code analysis, and graph validation when available.
Step 5: Answer With Evidence
Every answer should include:
- The Ontoly capability or query used.
- The node, edge, route, package, or diagnostic evidence that supports the answer.
- A confidence statement derived from graph evidence.
- Any known limitations caused by missing graph regions or diagnostics.
Step 6: Fall Back Gracefully
Only inspect repository files directly when Ontoly cannot answer, the graph is missing, diagnostics make the graph untrustworthy for the question, or the user asks for source-level verification. When falling back, explain which graph evidence was insufficient.
Examples
Architecture Review
User asks: "Explain this repository."
Workflow:
- Verify or build the Ontoly graph.
- Check graph trust, diagnostics, detected frameworks, packages, modules, services, routes, and largest dependency hubs.
- Use Ontoly's architecture summary or equivalent query.
- Report the architecture with graph evidence and confidence.
Request Tracing
User asks: "Trace the login flow."
Workflow:
- Search graph nodes for authentication routes and controllers.
- Trace route-to-controller-to-service-to-repository relationships.
- Include unresolved edges or missing relationships as limitations.
- Avoid opening source files unless the graph cannot identify the flow.
Impact Analysis
User asks: "What breaks if I remove UserRepository?"
Workflow:
- Locate the graph node for
UserRepository. - Query callers, consumers, dependency injection edges, modules, routes, and packages that reference it.
- Separate direct dependents from transitive impact.
- Include confidence based on explicit graph relationships.
Best Practices
- Prefer Ontoly graph queries before grep, AST parsing, or broad file search.
- Keep graph evidence separate from inference.
- Treat diagnostics as part of the answer, not as noise.
…
FAQ
What is a 'Software Graph'?
It's a detailed map of a project's code, showing how different components (files, functions, etc.) relate to and depend on each other.
Do I need to install anything?
The tool might need to be installed or set up, depending on whether the project already uses it. It will try to check this first.
What happens if the tool can't find information?
If the code 'map' is incomplete or has issues, the tool will state the limitations and, if necessary, may look directly into the project files.
Details
Original description by the author
Use Ontoly's deterministic Software Graph, MCP server, and agent skills for architecture review, request tracing, impact analysis, and dependency analysis.
Popularity
- GitHub stars
- 48k
- Ranking position
- #3759
- License
- MIT
- Updated
- 10/15/2026
Comments
- …
More skills from this repository
00-andruia-consultant
Helps your agent start or improve AI projects. It analyzes code, suggests tools, and creates action plans in Spanish.
sickn33/agentic-awesome-skills
007
Lets your agent perform security audits and threat modeling. It's useful for protecting projects against attacks and vulnerabilities.
sickn33/agentic-awesome-skills
10-andruia-skill-smith
Helps your agent create or improve AI tools. It defines how tools work, writes documentation, and validates the structure.
sickn33/agentic-awesome-skills
20-andruia-niche-intelligence
Lets your agent create a summary about a specific industry. It's useful for understanding the context, rules, usage patterns, and risks of a project, using reliable sources.
sickn33/agentic-awesome-skills
Similar skills
benchmark-optimization-loop
Has your agent improve something's speed in a measured way. It tests multiple versions and chooses the fastest one that still works correctly.
affaan-m/ECC
change-impact
Helps your agent analyze the impact of code changes before making them. It compares the planned vs. actual results afterward, covering paths, data, tests, and documentation. Useful for risky or system-wide changes.
affaan-m/ECC
click-path-audit
Lets your agent trace all user buttons and interactions to find bugs. It finds issues where functions seem to work alone but fail together. Useful when bugs persist even after debugging.
affaan-m/ECC