alphaagent-team

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

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 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.

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

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

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

Patterns for designing RESTful and GraphQL APIs

Patterns for implementing authentication and authorization in backend applications

Patterns for consistent error handling in backend applications

Patterns for designing and implementing Express middleware

Jest async testing patterns

Jest code coverage configuration and analysis

Jest mocking patterns and techniques

Jest testing patterns and best practices

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

Detects similar/duplicate tickets before creating new ones.

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

Node.js async/await patterns

Node.js error handling patterns

Node.js performance optimization patterns

Node.js stream patterns

TypeScript type inference patterns and techniques

TypeScript best practices and common patterns

Built-in TypeScript utility types and their applications

PostgreSQL indexing strategies and optimization

PostgreSQL migration patterns and best practices

PostgreSQL performance tuning and optimization

PostgreSQL query patterns and best practices

Prisma migration workflow patterns

Prisma Client query patterns

Prisma relation modeling patterns

Prisma schema design 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.

Patterns for building accessible web applications following WCAG guidelines

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

Patterns for building responsive, mobile-first user interfaces

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

Patterns for entity relationship design and data modeling

Patterns for safe database migrations in production environments

Patterns for optimizing database query performance

Patterns for designing database schemas with proper normalization and relationships

Vite configuration patterns

Vite Hot Module Replacement patterns

Vite plugins and ecosystem

Auth0 integration with Express.js

Auth0 integration with Next.js

Auth0 integration patterns

TypeORM entity definition patterns

TypeORM migration patterns

TypeORM query patterns

Common Tailwind component patterns

Tailwind CSS utility patterns and best practices

Tailwind responsive design patterns

Material-UI component patterns and usage

Material-UI styling approaches

Material-UI theme customization

Deployment strategies and patterns

GitHub Actions workflow patterns

Continuous improvement processes and patterns

Evaluation frameworks and assessment methodologies

Software quality metrics and measurement

better-sqlite3 library patterns

SQLite performance optimization techniques

SQLite database patterns and best practices

Code coverage analysis and improvement patterns

Test data creation and management patterns

Test planning and strategy patterns

Common system design patterns and architectures

Sprint planning and technical roadmap patterns

API documentation standards and patterns

Documentation structure and organization patterns

Content strategy and planning patterns

Technical writing standards and best practices

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