skills-alena

Run a comprehensive audit of the codebase covering security, performance, architecture, and database.

Create or verify named progress checkpoints with git snapshots and test status.

Stage changes and create a well-formatted conventional commit.

Switch context mode to change how the assistant behaves (dev, research, or review).

Systematically debug an issue using structured diagnosis.

Run a brutal, exhaustive, multi-pass audit of the entire product. 5 passes: build, routes, data flow, user flows, edge cases. No shortcuts. Creates actionable task list.

Run pre-deployment safety checks.

Capture user preferences and lock decisions BEFORE planning begins. Prevents replanning from misaligned assumptions.

Generate or update documentation for the specified code.

Execute an implementation plan with wave-based parallelization, deviation handling, checkpoints, and deterministic state tracking.

Explain code with analogies, diagrams, and step-by-step walkthrough.

Fix a GitHub/Linear issue by number.

Audit the product for functional completeness — find placeholder pages, broken flows, disconnected APIs, and missing states. Distinguish between 'looks done' and 'is done'.

Initialize a new project with deep context gathering, planning structure, and roadmap.

Integrate an API from a product manager's spec into the frontend with full surface mapping, modular SOLID-compliant API layer, and integration testing.

Extract reusable patterns and learnings from the current session and save to .planning/LEARNINGS.md.

Run the learning-first /lmf flow for tutorial-style planning, explanation, and copyable code before execution.

Run a repetitive task across multiple targets with safety bounds and progress tracking.

Manage persistent memory — init, read, write, compress, status.

Plan and execute database or code migrations with rollback safety.

Chain multiple agents in sequence with structured handoffs for complex multi-step tasks.

Profile, analyze, and optimize application performance with structured benchmarking.

Create a detailed implementation plan with task anatomy, context budgets, and user decision enforcement.

Create a product requirements document through an interview-first PRD workflow.

Show current project progress, phase status, and task completion.

Run technical quality checks before commits or PRs — build, types, lint, test, security, diff review.

Execute a small task without full project planning — for quick fixes, small features, and one-off changes.

Run a full UI/UX redesign audit — inventories backend, audits every component, extracts design tokens, analyzes user flows, and produces layered redesign recommendations

Safely refactor code with verification at each step.

Deep research on a topic, technology, or codebase area before planning or implementation.

Perform a thorough code review of specified files or the current diff.

Run comprehensive security analysis across code, dependencies, secrets, and configuration.

View or modify project planning configuration — mode, depth, workflow toggles, and preferences.

Start a multi-agent council session with real subagent spawning and deterministic state management

Generate comprehensive tests for specified code.

Validate built features through systematic verification and conversational UAT.

Scientific debugging agent — investigates issues using hypothesis-driven methodology with evidence chains, persistent state, and checkpoint handling.

Plan execution agent — implements tasks from plans with deviation protocol, checkpoint handling, context fidelity, mandatory file reads, and deterministic state tracking.

Bug fix implementation agent — implements targeted fixes based on investigation findings with minimal change footprint and comprehensive verification.

Bug investigation agent — systematically traces issues from symptoms to root cause through hypothesis generation, log analysis, and reproduction.

Codebase mapping agent — creates comprehensive structural maps including module boundaries, dependency graphs, architectural patterns, and complexity analysis.

Task breakdown and implementation planning agent — creates executable prompt plans with structured output, init command usage, task anatomy, wave assignment, and dependency-aware sequencing.

Deep codebase and domain research agent — gathers evidence, maps patterns, and builds context before planning or execution begins.

Code review agent — examines code changes for correctness, security, performance, patterns, and maintainability with structured, severity-based feedback.

Work verification and gap analysis agent — validates implementation against requirements using goal-backward analysis, checks each requirement against actual code, and generates structured VERIFICATION.md.

Use as the master reference for all core principles, anti-hallucination protocol, severity framework, and skill activation rules. Every other skill inherits from this. Read this first in any new session.

Use when auditing UI for accessibility, WCAG compliance, keyboard navigation, screen reader support, or when building inclusive interfaces.

Multi-agent council using real subagent spawning (Task() tool), deterministic CLI state management, and file-based handoffs. Orchestrator stays lean while specialists execute in fresh contexts.

Use when designing, reviewing, or auditing APIs — REST, GraphQL, RPC, WebSocket. Covers endpoint design, request/response contracts, versioning, error handling, pagination, rate limiting, and documentation.

Use when asked to audit, evaluate, or understand a codebase's architecture. Covers structure, patterns, coupling, cohesion, and architectural drift. Use after codebase-mapping for full context.

Use before any creative work — creating features, building components, adding functionality, or modifying behavior. Explores intent, requirements, and design before implementation.

Use when you need an absolutely thorough, no-shortcuts, multi-pass audit of the entire product. Covers build verification, route checking, data flow tracing, user flow testing, and edge case validation. Forces file-by-file verification with explicit tracking. Creates an actionable task list. Cannot cut corners.

Use when auditing build pipelines, deployment processes, CI/CD configuration, environment management, or release workflows. Covers build reliability, deployment safety, rollback capability, secrets management, and environment parity.

Use when completing tasks, implementing features, before merging, or when asked to review code. Systematic review process covering correctness, security, performance, and maintainability.

Use when adding any new code, feature, component, or endpoint to an existing codebase. Enforces pattern uniformity by requiring observation of existing code patterns before writing, matching them exactly, and double-verifying conformity. Covers frontend, backend, naming, structure, error handling, data flow, and styling patterns.

Use when first encountering a codebase, onboarding to a project, or needing to understand system structure before auditing or modifying. Creates a mental model of the system before any changes.

Use when auditing database schema, migrations, data integrity, query patterns, or when asked about database architecture. Covers schema design, indexing strategy (including high-volume tables), migrations, constraints, query optimization, and data consistency. Especially critical for tables with text-heavy columns, large datasets (logs, activity, notifications), and missing indexes.

Use when reviewing project dependencies, investigating supply chain security, checking for outdated packages, or evaluating new dependencies to add.

Use when you have a detailed implementation plan and need to execute it task by task with deviation handling, checkpoints, and atomic commits.

Use when auditing frontend code — component architecture, state management, accessibility, design system consistency, bundle size, and rendering performance. Framework-agnostic with specific guidance for React, Vue, Svelte, and vanilla JS.

Use when integrating APIs from a product manager, designer, or spec document into an existing frontend. Covers full-surface mapping, modular API layer creation, systematic replacement of mocks/placeholders, and integration testing. Prevents partial integration, broken pages, and placeholder-driven development.

Use when performing any git operations — branching, committing, merging, rebasing, resolving conflicts. Ensures clean history, atomic commits, and proper branch management.

Use during production incidents — outages, security breaches, data corruption, performance degradation. Provides structured triage, mitigation, resolution, and post-mortem processes.

Use when the user wants a learning-first walkthrough, tutorial-style implementation guidance, or /lmf behavior before or alongside execution.

Use when auditing logging, monitoring, alerting, tracing, or metrics. Covers structured logging, error tracking, health checks, dashboards, distributed tracing, and incident detection capabilities.

Use when investigating slow responses, high resource usage, scaling concerns, or when asked about performance. Covers database queries (N+1), memory, CPU, rendering, caching, and load patterns.

Automated persistent memory system for AI agents — captures decisions, context, and learnings across sessions using file-based protocols. Works in Antigravity, Cursor, Claude Code, and any agent that can read/write files.

Use when a product looks 'done' but flows are broken, pages are placeholders, data is hardcoded, or the frontend and backend are not fully connected. Audits every route, every flow, every component for functional completeness vs visual completeness.

Use when changing existing code — restructuring, renaming, extracting, inlining, or migrating. Ensures behavior is preserved through methodical, test-backed transformations.

Use when asked about security, when auditing a codebase, before deploying to production, or when handling user data. Covers authentication, authorization, injection, data exposure, dependencies, and infrastructure.

Use for ANY technical issue — test failures, bugs, unexpected behavior, performance problems, build failures, integration issues. Especially when under time pressure, when 'just one quick fix' seems obvious, or when previous fixes didn't work.

Use during any implementation work — new features, bug fixes, refactors, behavior changes. Enforces the RED-GREEN-REFACTOR cycle. No production code without a failing test first.

Use when the frontend needs a visual overhaul — redesign with uniformity. Exhaustively audits the existing frontend (design tokens, components, layouts, typography, color, spacing, animations), maps every backend API and data model, identifies UI/UX problems, and generates a prioritized redesign plan with concrete before/after suggestions. Framework-agnostic.

Use when a task could benefit from the skills library. Guides skill discovery, activation, composition, and effective application.

Use when about to claim work is complete, fixed, passing, or done. Requires running verification commands and confirming output before making any success claims. Evidence before assertions, always.

Use when the user wants a PRD, product requirements document, feature brief, or interview-first product specification before implementation.

Use when creating or updating documentation — READMEs, API docs, architecture docs, onboarding guides, or inline code documentation.

Use when you have a spec or requirements for a multi-step task and need to create a detailed implementation plan before touching code.

Use when creating new skills for the skills library. Defines the structure, format, quality standards, and testing requirements for new skills.