.AI

Evidence-driven debugging loop with mandatory instrumentation + fix approvals, run_id-tagged logs, default 3-pass verification for flaky issues, and guaranteed cleanup of debug-only instrumentation.

Retrieve and review deferred ideas from `.ai/project/ideas/ideas.yaml` without writing files. Use when the user asks to list, filter, summarize, prioritize, or re-evaluate recorded ideas and decide which ones are still valid.

Govern the deferred ideas ledger at `.ai/project/ideas/ideas.yaml`. Use when the user asks to persist a new "not-now-but-later" idea, edit idea fields, change status, or mark ideas implemented/invalidated/stale. This skill is the only writer for the ideas ledger.

Apply consistent naming conventions for directories, files, and identifiers - covers kebab-case rules, SSOT layout, skill naming standards, and script-generated file paths (including temporary files under .ai/.tmp/).

Build a complete, production-embedded Agent module for a real feature request (API + optional worker/sdk/cron/pipeline), including blueprint, scaffolded runtime, prompt pack, docs, and registry entry. Enforces explicit user approvals, no-secrets-in-repo, fixed API route names (run/health), and conversation/memory strategy decisions.

Entry workflow for LLM engineering tasks (provider integration, calling wrapper, routing profiles, prompt templates, cost/telemetry, credentials/config keys). Routes to one procedure and enforces required verification.

Create a goal-aligned macro-level roadmap artifact (dev-docs/active/<task>/roadmap.md) by asking clarifying questions and recording assumptions; planning only (no code changes).

Apply consistent code review standards - covers review scope, feedback quality, approval criteria, and common review patterns.

Apply consistent Git conventions for commits, branches, and pull requests - covers commit message format, branch naming, and PR best practices.

Fetch and mutate frontend data with a consistent cache strategy (query keys, invalidation, suspense/loading, error handling, optimistic updates).

Apply LLM-first documentation standards when writing or reviewing docs - covers structure, semantic precision, token efficiency, and verification.

Project hub synchronizer and validator. Scans the repo (including multiple dev-docs roots), validates project/task metadata against the Project Contract, and can repair drift by generating missing task identity meta (.ai-task.yaml) and regenerating derived views under .ai/project/<project>/. Works in check-only mode for CI and apply mode for manual repair.

Design and implement backend tests (unit, integration) for services and HTTP endpoints with clear acceptance criteria.

Execute dependency-aware code refactors (moves, extraction, import rewrites) incrementally with approval gates, rollback points, and continuous verification.

Project-level orchestrator for intake and continuity. Turns a new/ongoing request into a governance decision (reuse vs new task, mapping to Milestone/Feature/Requirement) and keeps the project hub consistent (registry/changelog/derived views). Focuses on planning and coordination, not product code changes.

Perform targeted web research by defining the question, prioritizing primary sources, capturing evidence in a table, and producing a cited, decision-oriented summary.

Review code changes for architectural consistency, correctness risks, security/performance concerns, and verification gaps; produce a prioritized, actionable review report.

Handle async/await and error propagation in backend services with consistent error types, wrappers, and response mapping.

Validate backend HTTP inputs (params, query, body) with schemas and return consistent 4xx errors for invalid requests.

Read-only progress reporter. Produces a structured status snapshot from existing project/task artifacts (project hub + dev-docs) and includes an actionable next command; never modifies repo files.

Manage backend configuration safely with typed, validated settings and clear separation between defaults and secrets.

Design and implement backend middleware (auth, validation, logging, rate limits, error boundaries) with predictable ordering and behavior.

Implement frontend routing with predictable route definitions, lazy loading, nested layouts, and error/404 handling.

Execute and record end-to-end smoke tests for authenticated API routes with sanitized evidence, side-effect verification, and a lightweight implementation review.

Apply schema changes from repo SSOT (prisma/schema.prisma) to a target DB via Prisma migrations, with diff preview + approval gate; then refresh LLM context (docs/context/db/schema.json).

Apply safe and maintainable backend database patterns (transactions, pagination, soft deletes, query optimization, data consistency).

Debug authenticated API route failures (401/403/404) by capturing a reproducible request, tracing auth and routing layers, applying minimal fixes with approval gates, and verifying with negative tests.

Fix frontend runtime errors (console exceptions, blank screens) by capturing repro steps and diagnostics, applying a minimal targeted fix, and verifying user-visible behavior.

Provide Redis design/operation guardrails and scenario playbooks to prevent common mistakes (keys, TTL, memory, cluster, locks, rate limits).

Apply cross-cutting backend service patterns across routing, services, repositories, validation, configuration, errors, and tests.

Map changed API routes into a testable inventory (method, path, request/response shapes, valid/invalid payloads) to drive smoke testing.

Install or update an Agent Skills bundle into a repository SSOT (.ai/skills/).

Build backend service and repository layers to isolate business logic from persistence and improve testability.

Organize a frontend codebase by feature/module with clear public exports, predictable naming, and minimal cross-feature coupling.

Resolve TypeScript compilation errors by grouping diagnostics, fixing root causes first, applying safe fix patterns, and verifying via a clean compile.

Optimize frontend performance through measurement-driven improvements (render optimization, code splitting, caching, virtualization).

Create a minimal smoke-test plan for authenticated API routes (happy path, one negative case, and persistence checks).

Implement or refactor backend HTTP routing and controllers using a layered pattern (routes delegate, controllers validate and call services).

Instrument backend services with logging, error tracking, metrics, and tracing to diagnose failures and performance issues.

Author or update developer documentation with progressive disclosure, explicit requirements, examples/templates, and actionable verification steps.

Apply frontend TypeScript standards for safety and maintainability (strict typing, props DTOs, safe utilities, no implicit any).

Turn one or more knowledge documents into a provider-agnostic Agent Skills bundle (SKILL.md + examples/templates), using a plan -> apply -> lint workflow.