lisa

Build a feature. Defines acceptance criteria, researches codebase, implements via TDD, reviews, verifies, and ships.

Fix a bug. Analyzes git history, reproduces, finds root cause, implements fix via TDD, verifies, and ships.

Create conventional commits for current changes

Prune local branches that have been deleted on remote

Push changes and create or update a pull request

Improve existing code. Identifies target, measures baseline, implements improvements via TDD, measures again, and ships.

Investigate an issue. Analyzes git history, reproduces, traces execution, checks logs, and reports findings with evidence.

Add Validation Journey section to existing ticket

Create JIRA epics/stories/tasks from code files with comprehensive quality requirements

Post captured evidence to JIRA and GitHub PR

Execute Validation Journey and capture evidence

Sync plan progress to a linked JIRA ticket

Analytical triage of a JIRA ticket -- ambiguity detection, edge case analysis, verification methodology

Verify JIRA ticket meets standards for epic relationships and description quality

Monitor application health. Checks health endpoints, logs, errors, and performance across environments.

Plan work. Defines acceptance criteria, researches codebase, maps dependencies, and breaks down into ordered tasks.

Increase test coverage to a specified threshold percentage

Creates an implementation plan from a ticket URL, file path, or text description

Deploys an agent team to research, implement, review and deploy a plan

Fix all violations of one or more ESLint rules across the codebase

Improve test quality by analyzing and strengthening weak, brittle, or poorly-written tests

Review local branch changes compared to main

Reduce the cognitive complexity threshold by 2 and fix all violations

Reduce max lines per function threshold and fix violations

Reduce max file lines threshold and fix violations

Checks for code review comments on a PR and implements them if required.

Review code changes. Runs quality, security, performance, product, and test reviews in parallel, then consolidates findings.

Compare project's Lisa-managed files against Lisa source templates and offer to upstream changes

Run an OWASP ZAP baseline security scan locally using Docker

Ship current changes. Commits, opens PR, handles review feedback loop, deploys, verifies, and monitors.

Architecture specialist agent. Designs implementation approaches, traces data flow, identifies files to modify, maps dependencies, finds reusable code, evaluates design patterns, and flags breaking changes.

Bug fix agent. Reproduces bugs as failing tests, implements fixes via TDD, and verifies the fix resolves the issue without introducing regressions.

Feature build agent. Translates acceptance criteria into tests, implements features via TDD, and verifies all criteria are met.

Debug specialist agent. Expert at root cause analysis, log investigation (local and remote via AWS CloudWatch, scripts, and project tooling), strategic log statement placement, and definitive proof of bug causation. Finds what is causing the problem without a doubt.

Analyzes git commit history and pull request context to document the decision-making process behind file changes. Use when you need to understand why and how files evolved over time.

JIRA lifecycle agent. Reads tickets, determines intent (Bug → Fix, Story/Task → Build, Epic → Plan), delegates to the appropriate flow, syncs progress at milestones, and posts evidence at completion.

Post-implementation learning agent. Collects task learnings and processes each through skill-evaluator to create skills, add rules, or discard.

Performance specialist agent. Identifies N+1 queries, inefficient algorithms, memory leaks, missing indexes, unnecessary re-renders, bundle size issues, and other software performance problems. Recommends optimizations with evidence.

Product/UX specialist agent. Defines user flows in Gherkin, writes acceptance criteria from user perspective, identifies UX concerns and error states, and empirically verifies behavior matches requirements.

Code quality specialist agent. Reviews correctness, coding philosophy compliance (immutability, function structure), test coverage, and documentation. Explains findings in beginner-friendly plain English, ranked by severity.

Security specialist agent. Performs threat modeling (STRIDE), reviews code for OWASP Top 10 vulnerabilities, checks auth/validation/secrets handling, and recommends mitigations.

Evaluates instructions, rules, patterns, and knowledge to determine if they warrant creating a new skill. Use when discovering reusable patterns, receiving new guidelines, or identifying knowledge that could benefit future sessions. This agent decides whether content is broad and reusable enough to justify skill creation.

Test specialist agent. Designs test strategy (matrix, edge cases, coverage targets, TDD sequence), writes comprehensive unit and integration tests, and reviews test quality. Tests behavior, not implementation details.

Verification specialist agent. Discovers project tooling and executes verification for all required types. Plans and executes empirical proof that work is done by running the actual system and observing results.

Acceptance criteria definition. Gherkin user flows (Given/When/Then), error states, UX concerns, and empirical verification from the user perspective.

Best practices for designing Claude Code agent files (.claude/agents/*.md). This skill should be used when writing or reviewing agent markdown files to ensure proper design with focused domains, correct tool access, reusable definitions, and separation of capabilities from lifecycle. Combines Anthropic's official guidance with battle-tested patterns from agent team usage.

8-step bug triage and implementation workflow. Ensures bugs are reproducible, root-caused, and fixable before implementation begins.

Codebase exploration and architecture analysis. Read files, trace data flow, identify modification points, map dependencies, find reusable code, evaluate design patterns.

9-step epic triage and 5-step implementation workflow. Ensures epics are fully scoped, broken down, and ordered before execution begins.

This skill should be used when creating conventional commits for current changes. It groups related changes into logical commits, ensures all files are committed, and verifies the working directory is clean afterward.

This skill should be used when pruning local branches that have been deleted on the remote. It fetches remote changes, identifies stale local branches, and safely deletes them.

This skill should be used when pushing changes and creating or updating a pull request. It verifies the branch state, pushes to remote, creates or updates a PR with a comprehensive description, and enables auto-merge.

Add a Validation Journey section to an existing JIRA ticket by analyzing the change type and generating appropriate verification steps with evidence markers.

This skill should be used when creating JIRA epics, stories, and tasks from code files or descriptions. It analyzes the provided input, determines the appropriate issue hierarchy, and creates issues with comprehensive quality requirements including test-first development and documentation.

Upload text evidence to GitHub pr-assets release, update PR description, post JIRA comment with code blocks, and move ticket to Code Review. Reusable by any skill that captures evidence and generates evidence/comment.txt + evidence/comment.md.

Parse a JIRA ticket's Validation Journey section, execute the verification steps using appropriate tools (curl, test commands, database queries), capture evidence, and post to JIRA + GitHub PR using the jira-evidence skill.

Syncs plan progress to a linked JIRA ticket. Posts plan contents, progress updates, branch links, and PR links at key milestones. Use this skill throughout the plan lifecycle to keep tickets in sync.

This skill should be used when verifying that a JIRA ticket meets organizational standards for epic relationships and description quality. It checks epic parent relationships and validates description completeness for coding assistants, developers, and stakeholders.

Enforces JSDoc documentation standards for this TypeScript project. This skill should be used when writing or reviewing TypeScript code to ensure proper documentation with file preambles, function docs, interface docs, and the critical distinction between documenting "what" vs "why". Use this skill to understand the project's JSDoc ESLint rules and established patterns.

This skill should be used when comparing a project's Lisa-managed files against Lisa's source templates to identify drift. It reads the project manifest, locates source templates, generates diffs for drifted files, and offers to upstream improvements back to Lisa.

Nightly direct-execution skill for increasing test coverage. Receives pre-computed threshold data, writes tests targeting coverage gaps, updates thresholds, commits, and creates a PR.

Nightly direct-execution skill for improving test quality. In nightly mode, focuses on tests for recently changed files. In general mode, scans all tests for the weakest ones. Commits and creates a PR.

Nightly direct-execution skill for reducing code complexity thresholds. Receives pre-computed threshold data, refactors violations, updates thresholds, commits, and creates a PR.

Performance review methodology. N+1 queries, inefficient algorithms, memory leaks, missing indexes, unnecessary re-renders, bundle size issues. Evidence-based recommendations.

This skill should be used when increasing test coverage to a specified threshold percentage. It runs the coverage report, identifies files with the lowest coverage, generates a brief with coverage gaps, and creates a plan with tasks to add the missing tests.

This skill should be used for any non-trivial request — features, bugs, stories, epics, spikes, or multi-step tasks. It accepts a ticket URL (Jira, Linear, GitHub), a file path containing a spec, or a plain-text prompt. It assembles an agent team, breaks the work into structured tasks, and manages the full lifecycle from research through implementation, code review, deploy, and empirical verification.

This skill should be used when fixing all violations of one or more ESLint rules across the codebase. It runs the linter, groups violations by rule and file, generates a brief with fix strategies, and creates a plan with tasks to implement the fixes.

This skill should be used when improving test quality. It scans the test suite for weak, brittle, or poorly-written tests, generates a brief with improvement opportunities, and creates a plan with tasks to strengthen the tests.

This skill should be used when performing a code review on local changes on the current branch compared to the main branch. It uses multiple parallel agents to check for bugs, CLAUDE.md compliance, git history context, previous PR comments, and code comment adherence, then scores and filters findings by confidence level.

This skill should be used when reducing the cognitive complexity threshold of the codebase. It lowers the threshold by 2, identifies functions that exceed the new limit, generates a brief with refactoring strategies, and creates a plan with tasks to fix all violations.

This skill should be used when reducing the maximum lines per function threshold and fixing all violations. It updates the eslint threshold configuration, identifies functions exceeding the new limit, generates a brief with refactoring strategies, and creates a plan with tasks to split oversized functions.

This skill should be used when reducing the maximum file lines threshold and fixing all violations. It updates the eslint threshold configuration, identifies files exceeding the new limit, generates a brief with refactoring strategies, and creates a plan with tasks to split oversized files.

This skill should be used when checking for code review comments on a pull request and implementing them if required. It fetches PR metadata and comments, generates a brief from unresolved feedback, and bootstraps a project to address the review comments.

Code quality review checklist. Correctness, coding philosophy compliance, test coverage, documentation quality. Findings ranked by severity in plain English.

How to create reliable bug reproduction scenarios. Covers failing tests, minimal scripts, environment verification, and reproduction evidence capture.

Root cause analysis methodology. Evidence gathering from logs, execution path tracing, strategic log placement, and building irrefutable proof chains.

Security review methodology. STRIDE threat modeling, OWASP Top 10 vulnerability checks, auth/validation/secrets handling review, and mitigation recommendations.

Run an OWASP ZAP baseline security scan locally using Docker. Checks for the ZAP baseline script, executes the scan, and summarizes findings by risk level with remediation recommendations.

Methodology for breaking work into ordered tasks. Each task gets acceptance criteria, verification type, dependencies, and skills required.

8-step task triage and implementation workflow. Ensures tasks have clear requirements, dependencies, and verification plans before implementation begins.

Test-Driven Development implementation workflow. RED: write failing test, GREEN: minimum code to pass, REFACTOR: clean up. Includes task metadata requirements, verification, and atomic commit practices.

Test strategy design. Coverage matrix, edge cases, TDD sequence planning, test quality review. Behavior-focused testing over implementation details.

Analytical triage gate for JIRA tickets. Detects requirement ambiguities, identifies edge cases from codebase analysis, and plans verification methodology. Posts findings to the ticket and produces a verdict (BLOCKED/PASSED_WITH_FINDINGS/PASSED) that gates whether implementation can proceed.

Verification lifecycle: classify types, discover tools, fail fast, plan, execute, loop. Includes verification surfaces, proof artifacts, self-correction loop, escalation protocol, and definition of done.

14 hooks across 7 events