cc-telemetry

Lore

Opinionated meta skills & plugin framework for deterministic results with Claude Code.

Lore bundles battle-tested skills, commands, agents, and workflows into a single Claude Code plugin. It provides structured approaches to common development tasks — from TDD and debugging to code review, feature research, and security scanning — so Claude follows repeatable, high-quality processes instead of improvising.

Installation

curl -fsSL https://raw.githubusercontent.com/LayerDynamics/lore/main/install.sh | bash

The installer clones the repo into ~/.claude/plugins/_src/lore, symlinks the plugin into ~/.claude/plugins/lore, optionally sets up extensions (browserx, trellio, cc-telemetry, findlazy, mcp-trigger-gateway, scratchpad), and offers to launch Claude Code with a guided tour.

Verify the installation:

# In a Claude Code session:
/lore:list

Quick Start

Once installed, Lore's skills and commands are available in any Claude Code session.

List everything available:

/lore:list

Run a security scan on your project:

/security-check:scan

Start a TDD workflow:

Use the test-driven-development skill to implement [your feature]

Plan a multi-step feature:

/planning-ext:plan

Deep-dive into unfamiliar code:

/code-intel:investigate how does authentication work in this project?

Research before building:

/research:research how to add WebSocket support --depth deep

Review code without git:

/local:local-code-review src/

Audit dependencies and configs:

/security-check:audit

---

Skills (25)

Skills are the core abstraction — structured markdown workflows (each a SKILL.md) that guide Claude through complex tasks deterministically. Skills are invoked by name in conversation or triggered automatically based on context.

Process & Execution Skills

Skill	What It Does	When to Use
brainstorming	Collaborative dialogue to explore intent, requirements, and design before implementation. Proposes 2-3 approaches with trade-offs, gets approval, then writes a design doc.	Before any creative or feature work — always brainstorm first
lifecycle-phases	Enforces a Clarify → Plan → Execute → Review lifecycle with wave-based parallel execution for each phase.	Managing project execution through structured phases
rarv-cycle	Core execution loop: Reason → Act → Reflect → Verify. Every autonomous action follows this cycle — no step is optional.	Any autonomous or semi-autonomous work
staying-on-request	Enforces task boundaries — do exactly what was asked, nothing more. Surfaces adjacent issues as TODOs without fixing them.	When you discover adjacent issues or feel tempted to refactor
context-engineering	Manages agent context windows, preserves state across sessions, coordinates information flow between agents.	When context is getting large or coordinating multiple agents
subagent-development	Executes implementation plans by dispatching a fresh subagent per task with two-stage review (spec compliance + code quality) after each.	Executing implementation plans with independent tasks
writing-plans	Guided discovery followed by a structured implementation plan. Reads project context, asks about inclusions and dev practices, writes a bite-sized plan to docs/plans/.	When you have a spec or requirements for a multi-step task

Debugging & Investigation Skills

Skill	What It Does	When to Use
debug	General debugging with root cause investigation. No fixes without understanding the cause first.	Encountering bugs, test failures, or unexpected behavior
systematic-debugging	Four-phase investigation methodology: reproduce → isolate → identify root cause → fix. Random fixes waste time.	Any bug or test failure — must complete all phases before proposing fixes
deep-investigation	Traces execution paths, follows call chains, maps service integrations, reads tests, surfaces exact file:line references.	Tracing how something works, investigating execution paths, preparing for code review
reading-unfamiliar-code	Efficiently orients in unfamiliar projects. Starts with entry points and project-level docs before reading source files.	New to a project, need to understand architecture before making changes
outline-understanding-user-request	Analyzes actual code (not docs) to understand ambiguous requests. Identifies affected systems and formulates clarifying questions.	Ambiguous requests that would drain context to understand

Code Quality & Review Skills