lsp-index-engineer

Configures and orchestrates Language Server Protocol (LSP) clients, builds semantic code indexes, and enables code intelligence features like go-to-definition, find references, hover documentation, and auto-complete. Use when you need to set up or debug language servers (e.g., typescript-language-server, intelephense, pyright, gopls, rust-analyzer), implement code navigation in an editor or toolchain, build a unified symbol graph across multiple languages, configure LSP server connections and capability negotiation, or create real-time semantic indexes (LSIF, nav.index.jsonl) for large codebases.

Quality

88%

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Passed

No known issues

Quality

Discovery

100%

Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.

This is an excellent skill description that thoroughly covers specific capabilities, provides rich trigger terms that developers would naturally use, and clearly delineates both what the skill does and when to use it. The description is well-structured with a concise capability summary followed by an explicit 'Use when' clause with multiple concrete scenarios. It occupies a clear, distinct niche around LSP and semantic code intelligence.

Dimension	Reasoning	Score
Specificity	Lists multiple specific concrete actions: configures LSP clients, builds semantic code indexes, enables go-to-definition, find references, hover documentation, auto-complete, debug language servers, implement code navigation, build unified symbol graphs, configure capability negotiation, and create real-time semantic indexes.	3 / 3
Completeness	Clearly answers both 'what' (configures LSP clients, builds indexes, enables code intelligence features) and 'when' with an explicit 'Use when...' clause listing five distinct trigger scenarios including setting up/debugging language servers, implementing code navigation, building symbol graphs, configuring LSP connections, and creating semantic indexes.	3 / 3
Trigger Term Quality	Excellent coverage of natural terms users would say: 'LSP', 'language server', specific server names (typescript-language-server, pyright, gopls, rust-analyzer), 'go-to-definition', 'find references', 'hover documentation', 'auto-complete', 'code intelligence', 'LSIF', 'symbol graph', 'code navigation'. These are terms developers would naturally use.	3 / 3
Distinctiveness Conflict Risk	Highly distinctive niche focused specifically on LSP protocol, language servers, and semantic code indexing. The specific mention of LSP, named language servers, LSIF, and capability negotiation makes it very unlikely to conflict with general coding or editor configuration skills.	3 / 3
	Total	12 / 12 Passed

Implementation

77%

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

This is a strong, highly actionable skill with excellent workflow clarity and validation checkpoints throughout. Its main weakness is that it's somewhat long and monolithic — the detailed code examples and schema definitions could benefit from being split into referenced files. The content is well-organized but could be more concise by trimming sections Claude could infer (e.g., basic class structure patterns).

Suggestions

Extract the GraphNode/GraphEdge schema and the full LSPOrchestrator class into referenced files (e.g., SCHEMA.md, ORCHESTRATOR.md) to improve progressive disclosure and reduce main file length.

Trim the 'Core Mission' bullet points since they largely duplicate the skill description and frontmatter context.

Dimension	Reasoning	Score
Conciseness	The skill contains some unnecessary verbosity — the 'Core Mission' section restates what the description already covers, and the performance targets table, while useful, adds bulk. The graph schema and code examples are reasonably dense but could be tightened (e.g., the LSPOrchestrator class includes boilerplate Claude could infer). However, it avoids explaining basic concepts like what LSP is.	2 / 3
Actionability	The skill provides fully executable TypeScript code for LSP client initialization, graph building, and consistency validation. It includes concrete bash commands for installing language servers, a specific JSONL format example, and a real protocol handshake test command. The code is copy-paste ready with meaningful structure.	3 / 3
Workflow Clarity	The 5-step workflow is clearly sequenced with explicit validation checkpoints after each step (marked with ✅). It includes feedback loops — e.g., checking capabilities before proceeding, running consistency assertions after each graph-building phase, and verifying WebSocket events. The assertGraphConsistency function is an excellent concrete validation step for a destructive/batch graph operation.	3 / 3
Progressive Disclosure	The content is well-structured with clear sections and headers, but it's a monolithic document with no references to external files for advanced topics (LSIF import/export details, per-language server quirks, API reference). The graph schema, full orchestrator code, and JSONL format could be split into referenced files to keep the main skill leaner.	2 / 3
	Total	10 / 12 Passed

Validation

90%

Warnings & errors only

Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.

Validation — 10 / 11 Passed

Validation for skill structure

Criteria	Description	Result
frontmatter_unknown_keys	Unknown frontmatter key(s) found; consider removing or moving to metadata	Warning

	Total	10 / 11 Passed

Repository: OpenRoster-ai/awesome-agents
Commit: 010799b

Reviewed: 5 days ago

Table of Contents

Discovery Implementation Validation

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.