A technical analysis tool for investigating impact, root causes, and architectural tradeoffs without modifying code.

Install

mkdir -p .claude/skills/analyse && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/15066" && unzip -o skill.zip -d .claude/skills/analyse && rm skill.zip

Installs to .claude/skills/analyse

Activation

This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.

Cross-cutting technical analysis. Investigates impact, tradeoffs, root causes, or feasibility without implementing changes. Use when asked to "analyse this", "investigate the impact", "what are the tradeoffs", "root cause analysis", "is this feasible?", or "compare these approaches". Produces an analysis report.
313 chars✓ has a “when” triggerlonger than Claude Code's old 250-char listing cap (fine on current versions)
Intermediate

Key capabilities

  • →Investigate impact of a change
  • →Compare different approaches (tradeoff analysis)
  • →Determine feasibility of a proposal
  • →Perform root cause analysis
  • →Analyze risks of an action
  • →Produce a structured analysis report

How it works

The skill defines the analysis question, gathers evidence from code and logs, structures the analysis around relevant dimensions, and presents findings with confidence levels in a structured report.

Inputs & outputs

You give it
A topic, change, or question to analyze
You get back
A structured analysis report with findings, conclusions, and recommendations

When to use analyse

  • →Compare different architectural implementation approaches
  • →Identify the root cause of a recurring system bug
  • →Determine the feasibility of a proposed technical change
  • →Evaluate the performance impact of a new dependency
  • →Analyze the side effects of refactoring legacy modules

About this skill

Skill Context

This skill is part of vstack — a VS Code-native AI engineering workflow system.

AskUserQuestion Format

When you need clarification, use this exact format — never invent or guess:

Question: [The specific question] Options: A) … | B) … | C) … Default if no response: [What you'll do]

Never ask more than one question at a time without waiting for the answer.

Diagram Convention

When producing hand-authored Markdown outputs, prefer Mermaid for flow, interaction, lifecycle, state, topology, dependency, and decision diagrams when the format is supported and improves clarity. Use ASCII as a fallback when Mermaid is unsupported or would be less readable. Keep ASCII/text trees for directory structures and other scan-friendly hierarchies.

# Detect base branch (main / master / develop / trunk)
BASE=$(gh pr view --json baseRefName -q .baseRefName 2>/dev/null) \
  || BASE=$(git remote show origin 2>/dev/null | grep 'HEAD branch' | awk '{print $NF}') \
  || BASE=$(git branch -r 2>/dev/null | grep -E '/(main|master|develop|trunk)' | head -1 | sed 's|.*origin/||') \
  || BASE="main"
echo "Base branch: $BASE"

analyse - Technical Analysis

Investigate impact, tradeoffs, feasibility, causes, risks, or change consistency. Do not implement changes, rewrite acceptance, or run a verification fix loop. Use debug for fixes, performance for profiling, architecture/adr for decisions, and verify for implementation checks.

Scope and evidence

Establish the question, scope, and known decisions from context. Ask only for material missing information. Read relevant code, callers, contracts, baselines, and data; do not launch a whole-repository audit by default.

Support findings with file locations, measured data, or explicit assumptions. Inspect history and dependents when relevant; distinguish facts from hypotheses.

Select relevant dimensions

AnalysisQuestions
ImpactDependents, blast radius, compatibility, migration, rollback?
TradeoffComplexity, performance, maintenance, cost, risk, effort per option?
FeasibilityStack capability, limits, dependencies, blockers?
CauseSymptom, timeline, primary cause versus contributing factors?
RiskLikelihood, impact, mitigation?
ConsistencyDo intent, acceptance, contracts, and useful tasks agree?

Change-consistency review

Use before implementation when explicitly requested or justified by risk. Read only relevant requirements, criteria, constraints, contracts, and tasks. Identify:

  • contradictions, including contracts conflicting with agreed behavior;
  • uncovered obligations or vague, untestable criteria;
  • proposed additions with no requirement or engineering rationale;
  • artificial prerequisites inferred from task order or role names.

For each finding, give source, consequence, and proposed next action. Necessary implementation details need not each be a product requirement. An unexplained addition is a scope question, not permission to delete code. Do not silently change intent, tasks, or implementation.

Output

Return a compact response: question/scope, findings with evidence and impact, recommendation, open questions, and confidence (certain, probable, uncertain). For consistency reviews, use the response or an existing document when authorized; no mandatory standalone report. A requested broader report may use the same structure. Requirement quality and consistency findings are not behavioral proof.

<!-- AUTO-GENERATED — maintained by vstack, do not edit directly --> <!-- VSTACK-META: {"artifact_name":"analyse","artifact_type":"skill","artifact_version":"20261026001","generator":"vstack","vstack_version":"4.0.0"} -->

When not to use it

  • →When the task is to fix bugs
  • →When the task is performance benchmarking with code changes
  • →When the task is architecture decisions or implementation

Limitations

  • →The skill does not implement changes.
  • →It does not perform full test runs.
  • →It requires repository file access and terminal command execution.

How it compares

This skill provides a structured, evidence-based approach to technical analysis, including impact, tradeoff, feasibility, root cause, and risk analysis, which is more systematic than an ad-hoc investigation.

Compared to similar skills

analyse side by side with the closest alternatives in the catalog.

SkillInstallsUpdatedSafetyDifficulty
analyse (this skill)04moReviewIntermediate
error-handling-patterns356moNo flagsIntermediate
cursor-explorer-mcp61yNo flagsIntermediate
analyzing-projects39moReviewBeginner

Try saying

Example prompts that trigger this skill in your AI assistant.

You might also like

error-handling-patterns

wshobson

Master error handling patterns across languages including exceptions, Result types, error propagation, and graceful degradation to build resilient applications. Use when implementing error handling, designing APIs, or improving application reliability.

35170

cursor-explorer-mcp

sepiabrown

Use for token-expensive operations requiring multi-file analysis - codebase exploration, broad searches, architecture understanding, tracing flows, finding implementations across files. Uses MCP cursor-agent server (company pays) with clean async interface. Do NOT use for single-file analysis, explaining code already in immediate context, or pure reasoning tasks.

699

analyzing-projects

CloudAI-X

Analyzes codebases to understand structure, tech stack, patterns, and conventions. Use when onboarding to a new project, exploring unfamiliar code, or when asked "how does this work?" or "what's the architecture?"

327

codebase-context-extractor

lofcz

This skill provides a comprehensive context extraction system for large codebases. It intelligently analyzes code structure, dependencies, and relationships to extract relevant context for understanding, debugging, or modifying code.

424

research-engineer

davila7

An uncompromising Academic Research Engineer. Operates with absolute scientific rigor, objective criticism, and zero flair. Focuses on theoretical correctness, formal verification, and optimal implementation across any required technology.

211

investigating-code-patterns

CaptainCrouton89

Systematically trace code flows, locate implementations, diagnose performance issues, and map system architecture. Use when understanding how existing systems work, researching concepts, exploring code structure, or answering "how/where/why is X implemented?" questions.

19

Search skills

Search the agent skills registry