LSP Analysis Skill

IntelliSense Designed for Coding Agent

Check our website!

This agent skill equips AI agents with the Language Server Agent Protocol (LSAP), enabling them to navigate, understand, and analyze codebases with the same fidelity as a human developer using VS Code.

📦 Installation

😎 Copy the following prompt to your agent and let it do all the heavy lifting for you:

Please follow these steps to install this skill:

1. Identify what AI agent tool you are (e.g., Claude Code, Gemini, Codex, OpenCode, etc.).
2. Determine the correct installation directory for your tool:
   - Claude Code: `~/.claude/skills/`
   - Gemini: `~/.gemini/skills/`
   - Codex: `~/.codex/skills/`
   - OpenCode: `~/.config/opencode/skill/`
   - Other tools:
     1. Search online to determine if your tool supports agent skills from `agentskills.io`.
     2. If supported, check your tool's documentation to get the skill directory.
3. Download the latest release and unzip it into that directory.

   For example, if you are Claude Code:

   ```bash
   # Create directory if it doesn't exist
   mkdir -p ~/.claude/skills/lsp-code-analysis

    # Download and unzip the latest release
    TMP_DIR=$(mktemp -d)
    curl -sSL https://github.com/lsp-client/lsp-skill/releases/latest/download/lsp-code-analysis.zip -o "$TMP_DIR/lsp-code-analysis.zip"
    unzip -o "$TMP_DIR/lsp-code-analysis.zip" -d ~/.claude/skills/
    rm -rf "$TMP_DIR"
   ```

Manual Installation

You can also use skills for easy installation:

npx skills add lsp-client/lsp-skill

⚡ Capabilities

The lsp-code-analysis skill provides compiler-accurate code understanding that surpasses text-based search:

🔍 Semantic Navigation: Jump to definitions, find references, locate implementations - understands code structure, not just text patterns.
🏷️ Language-Aware: Distinguishes between variables, functions, classes, types - eliminates false positives from text search.
🔗 Cross-File Intelligence: Trace dependencies, refactor safely across entire codebase - knows what imports what.
📘 Type-Aware: Get precise type information, signatures, documentation - without reading implementation code.
🗺️ Symbol Outline: Generate high-level structural maps of files to understand code without reading full implementations.

🚀 Getting Started

How it Works

This skill wraps the lsp command line tool, which acts as a bridge between the agent and standard Language Servers (like basedpyright, ``typescript-language-server, rust-analyzer`).

When an agent invokes this skill:

Intelligent Locating: The skill converts fuzzy intents (e.g., "find the process function") into precise file coordinates using LSAP's anchoring mechanism.
Server Management: It automatically manages the lifecycle of background language servers.
Cognitive Snapshots: It returns code context in optimized Markdown formats designed for LLM reasoning (Progressive Disclosure).

🌐 Supported Languages

This skill currently provides out-of-the-box support for the following languages:

Language	Language Server
Python	basedpyright
Rust	rust-analyzer
TypeScript / JavaScript	typescript-language-server
Go	gopls
Deno	deno lsp
Java	jdtls

More language support coming very very soon!

📚 Documentation

Skill Reference: Complete command reference and best practices.
Configuration Guide: Customizing lsp-cli settings and environment variables.
Frontend Best Practices: LSP workflows for frontend development.
Backend Best Practices: LSP workflows for backend development.

🔌 Extensible Best Practices

This skill uses a modular best practices system that can be extended for specific languages, frameworks, or workflows.

skills/lsp-code-analysis/references/
├── bp_frontend.md                 # Frontend development workflows
├── bp_backend.md                  # Backend development workflows
└── bp_<category>_<scenario>.md    # Custom domain-specific guides

Add your own:

just new-bp python django          # -> bp_python_django.md
just new-bp modify api-migration   # -> bp_modify_api-migration.md

See CONTRIBUTING.md for details.

🔄 Extensibility

This Agent Skill features a three-tier extensibility design that ensures its capabilities will continue to grow:

1. Foundation Expansion - LSP Client

The underlying lsp-client library continuously expands support for more language servers and LSP protocol capabilities.

Full LSP 3.17 Specification Coverage: As the LSP protocol evolves, new standard capabilities (Type Hierarchy, Call Hierarchy, Inline Values, etc.) will be continuously integrated

2. Tool Capability Expansion - LSP CLI & LSAP Protocol

The integrated LSP CLI implements the LSAP (Language Server Agent Protocol) to provide high-level, agent-optimized capabilities:

Advanced Analysis Capabilities: Upcoming Relation API, Impact Analysis, Code Map, and more
Optimized Output Formats: Continuously improving Markdown rendering templates using the Progressive Disclosure principle, providing code context better suited for LLM reasoning

3. Scenario Coverage Expansion - Best Practice System

This skill adopts a modular Best Practice system, enabling community contributions of domain-specific workflows:

Domain Expert Knowledge: Specialized workflows for different domains including Frontend (bp_frontend.md), Backend (bp_backend.md), and more
Framework/Language Specialization: Customized LSP usage guides can be added for specific tech stacks (e.g., Django, React, FastAPI)

These three layers of extensibility work together: the foundation provides raw tool materials, composed capabilities design efficient tool combinations, and best practices apply these tools to concrete scenarios. As all three continue to evolve, this skill will become increasingly powerful and user-friendly.

📦 Components

This repository is a self-contained Agent Skill that bundles:

Skill Definition: skills/lsp-code-analysis/SKILL.md
Best Practice Guides: skills/lsp-code-analysis/references/
Protocol Specs: LSAP Reference

lsp-code-analysis