Results for “codebase analysis”

Produce a structured codebase analysis report with architecture overview, critical files, patterns, and actionable recommendations. Use when asked to "analyze codebase", "explore codebase", "understand this codebase", "map the codebase", "give me an overview of this project", "what does this codebase do", "codebase report", "project analysis", "audit this codebase", or "how is this project structured".

The English summary is being prepared. Showing the original description.

Combine code from local directories or GitHub into one structured file for AI analysis. Examine project structure, search for related code, and check estimated tokens, the units AI models use to process text.

• Preparing a single codebase file for AI analysis
• Reviewing a project's directory structure
• Finding authentication code and database models

Analyze business concepts in a codebase to map business areas and suggest service boundaries. Use Domain-Driven Design, an approach organized around business meaning, to classify responsibilities, assess how closely they belong together, and recommend clearer integration points.

• Mapping business capabilities in an unfamiliar codebase
• Planning service boundaries around business terminology
• Reviewing mixed responsibilities before refactoring

Get a quick structural overview of a codebase with Trailmark. The skill identifies programming languages, counts entry points where execution begins, and returns dependency information to support orientation before deeper analysis.

• Getting oriented in an unfamiliar codebase
• Checking languages and entry point counts before analysis
• Preparing a structural overview for Vivisect or Galvanize

Scans code for security vulnerabilities with CodeQL by tracing data across functions. Builds and checks analysis databases, models project-specific APIs, and saves findings in SARIF, a structured results format, with broad or focused scan options.

• Scanning a codebase for security vulnerabilities
• Tracing untrusted input through custom APIs
• Choosing broad or high-precision security scans

Turn a large codebase spanning multiple repositories or services into a structured knowledge base. It documents architecture, business rules, and dependencies, links conclusions to source lines, labels confidence in relationships, and supports incremental updates.

• Documenting architecture across multiple repositories
• Tracing service dependencies and business rules
• Updating a knowledge base after code changes

Interactive codebase orientation for a HUMAN who wants to learn the code. Runs the same tree-sitting + featuring pipeline as exploring-codebases but synthesizes it into guided exercises and an HTML teaching artifact rather than an analysis document. Use for "orient me to this repo", "teach me this codebase", "walk me through this code", "learning orientation", or when someone wants genuine comprehension rather than a task completed. The audience is the test: if nobody is being taught and the goal is to get work done, use exploring-codebases instead.

The English summary is being prepared. Showing the original description.

Analyze an arbitrary codebase to identify functions, APIs, and data sources suitable for exposure as MCP tools, producing a tool specification document. Use when planning an MCP server for an existing project, auditing a codebase before wrapping it as an AI-accessible tool surface, comparing what a codebase can do versus what is already exposed via MCP, or generating a tool spec to hand off to scaffold-mcp-server.

The English summary is being prepared. Showing the original description.

コードベースのアーキテクチャを 6 つの専門エージェントチーム（Claude 5体 + Codex 1体）で 多角的に分析し、リスク・デグレしやすい箇所・改善ポイントを洗い出すスキル。 パフォーマンス、スケーラビリティ、信頼性、セキュリティ、運用、DX、データ整合性、依存関係の 8 観点を 5 グループに分担し、さらに Codex がクロスカットレビュアーとして横断分析する。 エージェント同士が反論・補足・自由な議論を行い、合意形成した結果をレポートとして出力する。 どのプロジェクトでも使える汎用スキル。 Use when: アーキテクチャを分析したい、リファクタリング前にリスクを把握したい、 デグレしやすい箇所を知りたい、コードの健全性を確認したい、大きめの実装前に注意点を洗い出したい、 技術的負債を可視化したい、コードベースの品質を監査したい。 Triggers: "arch review", "アーキテクチャ分析", "アーキテクチャレビュー", "リスク分析", "コード監査", "codebase audit", "技術的負債", "デグレしやすい", "architecture analysis", "risk analysis", "コードの健全性", "品質チェック", "実装前の確認"

The English summary is being prepared. Showing the original description.

Audit a codebase across nine areas, including architecture, tests, security, and documentation. Produces TECH_DEBT_AUDIT.md with source locations, severity ratings, estimated repair effort, and prioritized recommendations to help plan maintenance work.

• Assessing a codebase before maintenance
• Prioritizing technical debt fixes
• Checking architecture and code consistency

Route codebase exploration, file analysis, and web research through context-mode tools in Antigravity CLI. Process large outputs outside the conversation and return focused findings, with indexed content available for later searches.

• Explore a codebase and summarize key findings
• Extract and count information in a file
• Index web content for follow-up searches

Read existing code to reconstruct system specifications, including architecture, data flows, APIs, and business rules. Produces documentation tied to code locations, separating observed behavior from inferences and questions that need clarification.

• Understand an undocumented legacy system
• Document existing APIs and business rules
• Map module dependencies and data flows

Prepare a codebase for an external security review by defining goals, running static checks, improving test coverage, and removing unused code. Assemble the review scope, verified build instructions, diagrams, and documentation into a package for auditors.

• Preparing a codebase for an external security audit
• Organizing fixes and missing tests before review
• Defining the review scope and a stable code version

Organize existing code components into business areas to prepare for service separation. Produce domain maps, component assignment tables, and refactoring plans that align namespaces, the naming structure used to organize code, with business responsibilities.

• Grouping existing components by business responsibility
• Planning service extraction from an existing application
• Aligning code namespaces with business areas

Access TeamAI workflows for sharing skills, rules, documents, and environment settings across AI coding tools. This entry skill loads version-matched guidance for team setup, synchronization, codebase knowledge, and sharing lessons from a session.

• Start sharing AI settings across a team
• Sync team skills across AI coding tools
• Build or search knowledge about codebase architecture

Analyzes an existing codebase using strategic Domain-Driven Design to discover bounded contexts, surface ubiquitous language and semantic collisions, find places where code boundaries diverge from domain boundaries, and produce an evidence-backed domain and context map. Use when the goal is DDD-specific: bounded context discovery, ubiquitous language analysis, domain model discovery, or mapping contested ownership and responsibility. The entire repository is a valid scope; no module or directory must be named first. Does not assess architectural coupling, cohesion, or technical debt — use architectural-analysis. Does not design service communication, integration patterns, or deployment topology — use architectural-analysis or plan-a-feature. Does not refactor code, diagnose bugs, or review code quality — use refactor, investigate, or code-review.

The English summary is being prepared. Showing the original description.

Use this skill when the user wants to turn code graph analysis into tracked GitHub issues — "audit the architecture", "find god nodes", "triage architectural debt", "run graphify and log issues", "what's over-coupled in this codebase", "create issues from graphify findings", "check for structural problems", "scan for architectural smells", or any request that combines codebase topology analysis with issue tracking. This skill runs graphify to build a dependency graph, parses GRAPH_REPORT.md for god nodes and structural patterns, converts findings into GitHub issue payloads, and optionally pushes them to the repo. It bridges static analysis and project management in a single automated pass. Requires graphify and gh CLI.

The English summary is being prepared. Showing the original description.

Analyze a codebase to create project-specific AGENTS.md instructions and supporting rule files. Detect the package manager and relevant conventions, preview proposed changes, or update existing guidance when the project’s tools change.

• Create agent instructions tailored to an existing project
• Generate a minimal AGENTS.md file
• Refresh instructions after changing development tools

Generate a customizable AI prompt for finding representative examples in an existing codebase. Configure analysis depth, categories, and snippets so GitHub Copilot can produce exemplars.md with real file references and explanations of coding conventions.

• Collecting existing code examples for team guidance
• Documenting patterns to follow when adding features
• Configuring the depth and format of a code example guide

Route code changes and SQL analysis to isolated Kortix work sessions with clear requirements and workspace details. Coordinate parallel investigations or independent pull request reviews, then summarize deliverables, verification results, and differences between findings.

• Delegate feature implementation or bug fixes to a separate session
• Compare two agents' approaches to a refactor
• Combine findings from two independent pull request reviews

Review medium to large code changes using checks selected for the actual patch. Analyze the change and surrounding code, assign focused reviews by function, file, or feature, and combine findings with locations, confidence levels, and supporting evidence.

• Reviewing patches of roughly 50 to 1,000 lines
• Checking risks specific to a changed feature
• Reviewing changes alongside callers and related implementations

Explain code structure and behavior with text diagrams, including before-and-after views of changes. Trace data flow and state changes, clarify design choices, and examine assumptions, possible failures, and interactions between tasks running at the same time.

• Understanding a patch through before-and-after diagrams
• Tracing a class's behavior and state changes
• Mapping component relationships across a codebase

Find other occurrences of a known bug across a codebase by tracing its root cause. Gradually broaden search patterns, assess matching candidates, assign severity, and document findings with rules to help prevent recurrence.

• Finding similar issues after discovering a vulnerability
• Building CodeQL or Semgrep queries from a known bug
• Checking whether similar code shares the same root cause

Scan source code for security weaknesses with Semgrep after approving the target and rulesets. Choose full results or focus on important findings, then receive merged results and a record of failed or skipped scans.

• Audit source code for security weaknesses
• Check for vulnerabilities before code review
• Focus on findings with medium-to-high confidence and impact