deep-explanation
Delivers technical explanations of Git Extensions flows based on internal documentation and verified source code.
Install
mkdir -p .claude/skills/deep-explanation && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/19324" && unzip -o skill.zip -d .claude/skills/deep-explanation && rm skill.zipInstalls to .claude/skills/deep-explanation
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.
**SDLC (SME-first) SKILL** — Explain a Git Extensions subsystem or end-to-end flow accurately, grounded in the DAG docs and verified against source. USE FOR: "how does X work", "explain the commit/checkout/push flow", "trace this from UI to git", onboarding walkthroughs, architecture questions. DO NOT USE FOR: making code changes, writing new docs (use doc-management), or trivial single-file lookups. Triggers: "explain how", "walk me through", "how does X work end to end", "trace the flow".Key capabilities
- →Explain Git Extensions subsystems
- →Trace flows from UI to git commands
- →Verify explanations against source code
- →Generate Mermaid diagrams for multi-step flows
How it works
The skill grounds explanations in L0 primers and master docs before verifying the logic against actual source files. It structures output using a Why-What-How framework.
Inputs & outputs
When to use deep-explanation
- →Understand how commit flows work
- →Trace UI actions to git commands
- →Onboard new team members to the architecture
About this skill
Deep Explanation
Produce an accurate, grounded explanation — never hand-wave.
Phase 1 — Become a mini-SME first (BLOCKING)
STOP — before explaining, ground yourself:
- Read the L0 primer.
- Open the master docs-index, pick the matching reading chain, and read those docs in order (L1 concept → L2 subsystem → L3 flow).
- Verify against source — open the actual
src/files the docs point to. Docs give the "why"; the code confirms the "how".
Phase 2 — Explain with structure
Use Why → What → How:
- Why — the motivation/design rationale (from the docs).
- What — the components/actors and how they connect.
- How — the concrete path, with code pointers (
ClassName/Method/ file links) the reader can open. Prefer pointers over pasted code.
Include a compact Mermaid diagram for multi-step flows (sequence or graph). Label the execution context (UI thread vs background) where it matters — see threading-model.
Phase 3 — Close the loop
- Note cross-tier hops explicitly (UI →
GitUICommands→Commands/GitModule→git). - Call out quirks/gotchas the code reveals (e.g. legacy
ArgumentStringvsIGitCommand). - End with pointers to the exact files to read next.
Hard rules
- NEVER state a class/method/flow you haven't verified in source or a DAG doc.
- Ground every claim in a code pointer or a doc reference.
- Keep it scannable: lead with a 2–3 line summary, then the structured explanation.
When not to use it
- →Do not use for making code changes
- →Do not use for writing new documentation
- →Do not use for trivial single-file lookups
Limitations
- →Requires verification in source or DAG doc
How it compares
This skill requires source-code verification and doc-chain reading rather than providing general or unverified explanations.
Compared to similar skills
deep-explanation side by side with the closest alternatives in the catalog.
| Skill | Installs | Updated | Safety | Difficulty |
|---|---|---|---|---|
| deep-explanation (this skill) | 0 | 13d | No flags | Advanced |
| react-expert | 8 | 5mo | Review | Advanced |
| rust-learner | 8 | 5mo | Review | Beginner |
| cartographer | 3 | 5mo | Review | Intermediate |
Try saying
Example prompts that trigger this skill in your AI assistant.
You might also like
react-expert
reactjs
Use when researching React APIs or concepts for documentation. Use when you need authoritative usage examples, caveats, warnings, or errors for a React feature.
rust-learner
actionbook
Use when asking about Rust versions or crate info. Keywords: latest version, what's new, changelog, Rust 1.x, Rust release, stable, nightly, crate info, crates.io, lib.rs, docs.rs, API documentation, crate features, dependencies, which crate, what version, Rust edition, edition 2021, edition 2024, cargo add, cargo update, 最新版本, 版本号, 稳定版, 最新, 哪个版本, crate 信息, 文档, 依赖, Rust 版本, 新特性, 有什么特性
cartographer
kingbootoshi
Maps and documents codebases of any size by orchestrating parallel subagents. Creates docs/CODEBASE_MAP.md with architecture, file purposes, dependencies, and navigation guides. Updates CLAUDE.md with a summary. Use when user says "map this codebase", "cartographer", "/cartographer", "create codebase map", "document the architecture", "understand this codebase", or when onboarding to a new project. Automatically detects if map exists and updates only changed sections.
repo-research-analyst
parcadei
Analyze repository structure, patterns, conventions, and documentation for understanding a new codebase
exploring-rust-crates
hashintel
Generate Rust documentation to understand crate APIs, structure, and usage. Use when exploring Rust code, understanding crate organization, finding functions/types/traits, or needing context about a Rust package in the HASH workspace.
investigation
talmolab
Scaffolds a structured investigation in scratch/ for empirical research and documentation. Use when the user says "start an investigation" or wants to: trace code paths or data flow ("trace from X to Y", "what touches X", "follow the wiring"), document system architecture comprehensively ("document how the system works", "archeology"), investigate bugs ("figure out why X happens"), explore technical feasibility ("can we do X?"), or explore design options ("explore the API", "gather context", "design alternatives"). Creates dated folder with README. NOT for simple code questions or single-file searches.