home / skills / grishaangelovgh / gemini-cli-agent-skills / project-feature-explainer

project-feature-explainer skill

safe

This skill provides a structured feature explainer for codebase features, delivering summaries, deep dives, and usage examples with reference templates.

npx playbooks add skill grishaangelovgh/gemini-cli-agent-skills --skill project-feature-explainer

Review the files below or copy the command above to add this skill to your agents.

Files (4)

SKILL.md

2.0 KB

---
name: project-feature-explainer
description: Expert guidance for explaining project features. Use this skill when you need to provide a comprehensive explanation of how a specific feature works, including summaries, deep dives, usage examples, and sequence/workflow diagrams. This skill has references directory which contains additional instructions `checklist.md`, `example-output.md` and `explanation-template.md` that MUST be used for every analysis.
---

# Project Feature Explainer Skill

This skill provides a systematic approach to analyzing and explaining a specific feature within a codebase.

## Workflow

1.  **Identify Entry Points:** Locate the main functions, classes, or API endpoints that trigger the feature.
2.  **Trace Dependencies:** Identify the internal modules, services, or external APIs the feature relies on.
3.  **Analyze Data Flow:** Understand how data enters the feature, how it's transformed, and where it's stored or returned.
4.  **Draft Explanation:** Structure the explanation using the mandatory sections below.
5.  **Verify:** Cross-reference the draft with the `references/checklist.md` to ensure completeness.

## Mandatory Output Structure

### 1. Feature Summary
A high-level overview (1-2 paragraphs) explaining *what* the feature does and *why* it exists.

### 2. Deep Dive (Technical Details)
A detailed breakdown of the internal implementation.
- **Key Components:** List the main files/classes/functions involved.
- **Logic Flow:** Step-by-step description of the execution path.
- **State Changes:** Describe any side effects (e.g., database updates, cache invalidation).

### 3. Usage & Examples
Code snippets or CLI commands showing how to use the feature.
- Include common parameters and expected outputs.
- Provide a "Happy Path" example.

## Guidelines
- **Be Concise:** Focus on the "how" and "why" without repeating obvious code logic.
- **Reference Code:** Use specific file paths and symbol names.
- **Contextualize:** Explain how this feature fits into the broader system architecture.

Overview

This skill provides expert guidance for analyzing and explaining a single project feature clearly and compactly. It produces a structured deliverable with a feature summary, a technical deep dive, and practical usage examples, following mandatory templates and a verification checklist located in the references directory.

How this skill works

The skill inspects the codebase to identify entry points (functions, classes, or endpoints) that trigger the feature, traces dependencies and external integrations, and maps data flow through the system. It then drafts an explanation using the provided explanation template and validates completeness against the checklist file in the references directory. The final output contains concrete file paths, symbol names, logic flow, state changes, and a happy-path usage example.

When to use it

Explaining a newly implemented feature for documentation or onboarding
Reviewing an unfamiliar area of the codebase before making changes
Preparing technical notes for feature handoff or code review
Creating focused user-facing or developer-facing docs for a specific capability
Auditing feature behavior for debugging or compliance

Best practices

Start by locating and listing explicit entry points (API routes, CLI commands, public functions).
Trace calls and imports to build a minimal dependency graph before writing the deep dive.
Reference concrete file paths and symbol names so readers can jump to code quickly.
Describe state changes clearly: databases updated, caches invalidated, events emitted.
Include a concise “happy path” usage example with common parameters and expected output.
Run the verification checklist from references/checklist.md before finalizing the draft.

Example use cases

Documenting an authentication flow: list middleware, token handling, and DB changes with examples.
Explaining a CLI command: show the command signature, flags, core handler function, and sample run output.
Clarifying a background job: identify the scheduler entry point, worker implementation, and side effects on persistence.
Preparing a pull request description: include the feature summary, key files changed, and a step-by-step logic flow for reviewers.

FAQ

Do I have to use the files in the references directory?

Yes. Use the explanation template to structure content and the checklist to verify completeness for every analysis.

How detailed should code references be?

Include exact file paths and symbol names needed to locate implementation; avoid reproducing large code blocks.

Is a sequence diagram required?

Provide a simple sequence or workflow diagram description in the deep dive; include ASCII, Mermaid, or a clear step list depending on target format.