open-docs

🥈Silver

Open-docs provides deep-dive documentation, implementation secrets, and architecture internals for AI CLI tools. It benefits developers, researchers, and power users by extracting information directly from source code. The skill connects to various AI CLI tools like Claude, Codex, and Gemini, enhancing understanding and implementation.

456440Updated Today

Intermediate30min to implementautomation

Saves ~30 min per use

Quick InstallView Source

git clone https://github.com/bgauryy/open-docs.git

Works with:

Claude

Overview

About This Skill

https://github.com/bgauryy/open-docs

How to Use

[{"step":"Identify the AI CLI tool and specific aspect you need documentation for. Use the [TOOL_NAME] and [SPECIFIC_ASPECT] placeholders in the prompt template to narrow down the request.","tip":"For tools like Claude CLI, focus on recent versions (e.g., v1.8.x). Check the tool's GitHub repository for the latest source code references."},{"step":"Run the prompt in your preferred AI assistant (e.g., Claude, ChatGPT, or Gemini) with the filled-in placeholders. For example: 'Extract and summarize the deep-dive documentation for the Codex CLI, focusing on plugin architecture.'","tip":"If the AI's response is too generic, follow up with: 'Provide code snippets or configuration examples for [SPECIFIC_TASK].'"},{"step":"Cross-reference the AI's output with official documentation or the tool's source code repository. Look for discrepancies or missing details in the AI's response.","tip":"Use the AI's output to locate relevant files in the source code (e.g., GitHub search for 'memory_engine')."},{"step":"Implement or troubleshoot based on the extracted information. Use the provided code snippets or configuration examples to test the tool's behavior.","tip":"For debugging, enable the tool's debug mode (e.g., `claude --debug`) and compare its output with the AI's summary."},{"step":"Document any new findings or corrections. Share the insights with your team or contribute to the tool's community (e.g., GitHub issues or forums).","tip":"If you discover undocumented features, consider opening a pull request to update the official documentation."}]

Use Cases

Explore undocumented features of AI CLI tools to enhance functionality.

Integrate various AI agents into a single workflow for improved productivity.

Identify and troubleshoot edge cases in AI tool implementations.

Understand the internal architecture of AI systems for better customization.

Setup & Installation

Quick Install

No install command available. Check the GitHub repository for manual installation instructions.

Alternative Install (Git Clone)

git clone https://github.com/bgauryy/open-docs

Requirements

Claude Code or compatible AI agent
Works with: Claude

Quick Start Guide

Install the Skill

Copy the install command above and run it in your terminal.

Open Your AI Agent

Launch Claude Code, Cursor, or your preferred AI coding agent.

Try It Out

Use the prompt template or examples below to test the skill.

Customize

Adapt the skill to your specific use case and workflow.

Usage Examples

Prompt Template

Extract and summarize the deep-dive documentation, implementation secrets, and architecture internals for the AI CLI tool '[TOOL_NAME]' (e.g., Claude CLI, Codex CLI, or Gemini CLI). Focus on [SPECIFIC_ASPECT] such as [EXAMPLE: memory management, plugin architecture, or API integration]. Include code snippets or configuration examples where relevant. Prioritize official documentation and source code references.

Example Output

### Deep-Dive: Claude CLI Memory Management Architecture

**Overview**
The Claude CLI (v1.8.2) employs a hybrid memory architecture combining persistent disk-based storage with in-memory caching for optimal performance. Memory is segmented into three layers:
1. **Short-term cache** (RAM, 512MB, TTL: 30s) for active sessions
2. **Long-term storage** (SQLite database, encrypted) for persistent context
3. **User-defined context files** (JSON/YAML) for project-specific data

**Key Implementation Details**
- **Session Isolation**: Each CLI invocation creates a temporary memory namespace that merges with the user's long-term memory on commit.
- **Garbage Collection**: Unreferenced memory blocks are auto-purged after 7 days unless pinned by a user annotation.
- **Security**: All memory dumps are encrypted using AES-256-GCM with per-user keys derived from the user's master password.

**Code Snippet: Memory Configuration**
```bash
# Enable debug mode to inspect memory usage
claude --debug-memory

# Pin a context file to prevent garbage collection
claude --pin-context /path/to/project.json

# View memory statistics
claude --memory-stats
```

**Architecture Internals**
The memory system is built on top of the `memory_engine` module in the CLI's source code (`/src/memory/engine.py`). Critical functions include:
- `load_memory_context()`: Loads user-specific memory from disk
- `merge_session_memory()`: Combines temporary and persistent memory
- `commit_memory()`: Persists changes to the SQLite database

**Performance Optimization**
For large projects (>100MB of context), the CLI automatically switches to a streaming memory model to avoid RAM exhaustion. Users can force this mode with:
```bash
claude --stream-memory /path/to/large_project/
```

**Common Pitfalls**
1. **Memory Leaks**: Unclosed sessions can bloat the SQLite database. Always use `claude --cleanup` after long debugging sessions.
2. **Encryption Overhead**: Enabling encryption adds ~15% latency to memory operations. Disable with `--no-encryption` for local development.
3. **Context Bloat**: Project-specific JSON files should be pruned regularly. Use `claude --analyze-context` to identify large files.

**References**
- Official Docs: https://docs.claude.ai/cli/memory
- Source Code: https://github.com/claude-ai/cli/blob/main/src/memory/engine.py