the-answerai/alphaagent-team

Patterns for building accessible web applications following WCAG guidelines

Patterns for designing RESTful and GraphQL APIs

API documentation standards and patterns

REST API best practices including request validation, error handling, authentication, rate limiting, and documentation. Use when building backend APIs.

Auth0 integration with Express.js

Auth0 integration with Next.js

Auth0 integration patterns

Patterns for implementing authentication and authorization in backend applications

better-sqlite3 library patterns

Patterns for branch naming, validation, and lifecycle management. Used by git-pr-manager agent.

Patterns for creating conventional commits with proper formatting and validation. Used by git-pr-manager agent.

Patterns for designing component hierarchies, composition, and reusable UI elements

Content strategy and planning patterns

Continuous improvement processes and patterns

Code coverage analysis and improvement patterns

Patterns for entity relationship design and data modeling

Safely handles API responses to prevent crashes from malformed JSON, HTML error pages, or unexpected response types. Use any time calling API endpoints.

Deployment strategies and patterns

Documentation structure and organization patterns

Multi-platform Electron build configuration - esbuild bundling, electron-builder setup, and distribution

Integrate external CLI tools (Claude, Node, npx) in Electron apps with proper PATH handling

Handle native Node.js modules in Electron - better-sqlite3, sharp, keytar packaging patterns

Critical path resolution patterns for Electron apps - avoid process.cwd() and __dirname pitfalls

Secure IPC patterns, credential storage, and API key management for Electron apps

Patterns for consistent error handling in backend applications

Evaluation frameworks and assessment methodologies

Authentication patterns for Express.js

Error handling patterns for Express.js applications

Express.js middleware patterns and implementation

Express.js routing patterns and organization

Input validation patterns for Express.js

Patterns for implementing end-to-end features across frontend, backend, and database

GitHub Actions workflow patterns

Patterns for analyzing GitHub issues to determine if they are still relevant or have been fixed.

Patterns for detecting duplicate GitHub issues before creating new ones.

Comprehensive planning methodology for GitHub issues - from analysis to implementation plan.

Patterns for keeping GitHub issue status synchronized with development progress.

Jest async testing patterns

Jest code coverage configuration and analysis

Jest mocking patterns and techniques

Jest testing patterns and best practices

Patterns for detecting duplicate Jira tickets before creating new ones and handling existing duplicates.

Patterns for sprint planning with Jira - capacity planning, ticket selection, and sprint organization.

Patterns for keeping Jira ticket status synchronized with actual work progress.

Patterns for analyzing Jira ticket quality and identifying improvement opportunities.

Methodology for analyzing Linear tickets to find duplicates, check relevance, and determine if issues have been fixed.

Patterns for designing and implementing Express middleware

Patterns for safe database migrations in production environments

Material-UI component patterns and usage

Material-UI styling approaches

Material-UI theme customization

Next.js App Router API route patterns

Next.js App Router patterns and conventions

NextAuth.js / Auth.js authentication patterns

Client Components patterns in Next.js App Router

Next.js middleware patterns for request processing

React Server Components patterns in Next.js

Node.js async/await patterns

Node.js error handling patterns

Node.js performance optimization patterns

Node.js stream patterns

Playwright assertion patterns and matchers

Playwright debugging techniques and tools

Playwright fixtures and test setup patterns

Playwright selector strategies and patterns

Playwright visual comparison and screenshot testing

PostgreSQL indexing strategies and optimization

PostgreSQL migration patterns and best practices

PostgreSQL performance tuning and optimization

PostgreSQL query patterns and best practices

Conduct comprehensive pull request reviews with security, architecture, and quality checks. Use when user wants to review a PR.

Prisma migration workflow patterns

Prisma Client query patterns

Prisma relation modeling patterns

Prisma schema design patterns

Intelligent workflow orchestrator that commits, pushes, and creates/updates PRs automatically. Use when user wants to save their work or create a PR.

Software quality metrics and measurement

Patterns for optimizing database query performance

React Context API patterns for state sharing and prop drilling elimination

React hooks patterns including custom hooks, useEffect, useMemo, and more

React component patterns, best practices, and architecture guidelines

React Testing Library patterns for component testing

Patterns for building responsive, mobile-first user interfaces

Patterns for designing database schemas with proper normalization and relationships

Security vulnerability scanning and OWASP Top 10 compliance checking. Use when reviewing code for security issues, validating authentication/authorization, or ensuring security best practices.

SQLite performance optimization techniques

SQLite database patterns and best practices

Detect project technology stack from package.json, config files, and code patterns. Use this skill FIRST before writing any technology-specific code to prevent hallucinations.

Patterns for managing application state - local, global, server, and URL state

Common system design patterns and architectures

Common Tailwind component patterns

Tailwind CSS utility patterns and best practices

Tailwind responsive design patterns

Sprint planning and technical roadmap patterns

Technical writing standards and best practices

Test data creation and management patterns

Test planning and strategy patterns

Detects similar/duplicate tickets before creating new ones.

Patterns for creating well-researched Linear tickets with codebase context.

TypeORM entity definition patterns

TypeORM migration patterns

TypeORM query patterns

TypeScript type inference patterns and techniques

TypeScript best practices and common patterns

Built-in TypeScript utility types and their applications

Vite configuration patterns

Vite Hot Module Replacement patterns

Vite plugins and ecosystem