Daniel Avila

Set up and manage AlloyDB for PostgreSQL clusters, instances, and backups. Includes guidance for MCP integration, a way for agents to operate databases, plus references for application connections, Terraform, authentication, and AI search capabilities.

• Create an AlloyDB cluster and primary instance
• Manage AlloyDB backups
• Automate database operations through MCP

Apply consistent coding practices across TypeScript, JavaScript, React, and Node.js projects. Get guidance on naming, types, error handling, API design, file organization, and tests to make code easier to read and maintain.

• Aligning coding conventions across a team
• Refactoring long functions and deeply nested code
• Reviewing React components and state updates

Organize Node.js, Express, and TypeScript APIs into layers with clear responsibilities. This guide covers request handling, business logic, database access, input validation, error tracking, configuration, and testing to support consistent implementation and refactoring across services.

• Adding an API endpoint with clearly separated responsibilities
• Organizing database access through Prisma
• Adding input validation and error tracking

Set up a local web search server using Bright Data SERP API and unfancy-search. Retrieve results from multiple engines, optionally expand queries with AI, and receive combined rankings with duplicates removed and results grouped by domain.

• Adding web search to a Claude Code agent
• Researching a topic through multiple related queries
• Filtering searches by region or domain

Provision a PostgreSQL database with Neon Instagres and save connection settings for application use and migrations. Includes setup examples for Drizzle and Prisma, initial data loading, and claiming a temporary database to keep using it.

• Provision a PostgreSQL database for development
• Configure database access with Drizzle or Prisma
• Load a SQL file with initial data

Design REST and GraphQL APIs by clarifying who will use them and how. Define data structures, errors, authentication, pagination, and versioning, then review examples to make the interface consistent and easier to use.

• Designing a new REST or GraphQL API
• Reviewing API specifications before implementation
• Defining shared API design standards for a team

Guides background processing in Node.js and TypeScript with BullMQ and Redis. Covers job queues, which hold tasks for later execution, along with scheduling, priorities, rate limits, worker concurrency, and dependencies between processing steps.

• Design a queue for background tasks
• Schedule jobs for later or repeated execution
• Organize dependent steps into a job flow

Build connections between applications and external APIs, interfaces used to exchange data with other services. The skill guides authentication, data conversion, webhook verification, request limits, retries, and troubleshooting to support reliable API clients.

• Connect payment, email, or SMS services to an application
• Implement OAuth and manage API credentials
• Verify webhooks and process incoming events

Make system design decisions by clarifying requirements, identifying constraints, and comparing the benefits and drawbacks of different approaches. Record the reasoning in architecture decision records, or ADRs, while considering simpler alternatives and the team's experience.

• Organizing requirements before designing a system
• Comparing architectural patterns and trade-offs
• Documenting the reasons behind design decisions

Design autonomous agents for Claude Code plugins, including when they should run, what tools they may use, and how they should respond. Provides configuration templates, prompt guidance, and validation steps for creating agent files.

• Create a code review agent
• Refine examples that trigger an agent
• Limit the tools an agent can use

Build AWS applications with managed services that reduce server administration. Follow patterns for Lambda functions, HTTP APIs, database access, and queued background processing, with guidance on deployment and delays when functions first start.

• Build HTTP APIs with Lambda and API Gateway
• Read and write application data in DynamoDB
• Process SQS messages with retries and a dead-letter queue

Integrate USDC payments into AI agents on Base L2. Guides setup for earning or paying, generates tailored code, and verifies configuration, covering escrow that holds funds until delivery and instant payments for HTTP requests.

• Building an agent that charges USDC for services
• Paying another agent for a specific service
• Trying payment flows in a local simulation

Turn API code into documentation covering endpoints, inputs, authentication, responses, and errors. Add request examples in multiple languages and usage guides to help developers understand and start using the API.

• Writing documentation for a new API
• Updating API documentation after code changes
• Preparing API guides for new developers or external users

Improve PostgreSQL performance through a staged workflow covering slow query analysis, indexes that speed up data access, query rewrites, configuration tuning, routine maintenance, and monitoring for production databases.

• Investigating slow PostgreSQL queries
• Reviewing database indexes
• Tuning database configuration

Build complex claude.ai artifacts with React, Tailwind CSS, and shadcn/ui. Create interfaces with multiple components, state management for changing data, and routing between views, then package the app into one self-contained HTML file for sharing.

• Creating interfaces with multiple components
• Building artifacts with changing data and multiple views
• Sharing a React app as a single HTML file

Document major technical decisions with their context, alternatives, reasoning, and consequences. The skill provides Architecture Decision Record templates and maintenance practices so teams can review past choices, track replacements, and explain decisions to new members.

• Recording reasons for technology choices
• Comparing design options and trade-offs
• Explaining past decisions to new team members

Investigate database slowdowns and plan measurable improvements to queries, indexes, caching, and scaling. The skill covers SQL and NoSQL systems, with guidance on monitoring, load testing, migrations, and balancing performance against cost.

• Analyze slow SQL queries and execution plans
• Resolve repeated database calls in APIs
• Plan indexes and caching for high traffic

Design PostgreSQL tables around actual queries and data volumes. Choose data types, validation rules, and indexes, then plan large table partitioning, access rules for individual rows, and schema changes with migration and rollback considerations.

• Designing tables for users, orders, and related data
• Reviewing data types, constraints, and indexes
• Planning large tables and frequent update workloads

Use Bash on macOS or Linux for file searches, log inspection, text processing, and process checks. Apply command chaining, pipes that pass text between commands, environment variables, and error handling when writing scripts.

• Finding files and searching their contents
• Inspecting logs, processes, and occupied ports
• Extracting and replacing text

Create and manage MySQL, PostgreSQL, and SQL Server databases on Google Cloud. Covers instance setup, users, backups, availability, and secure connections, with a PostgreSQL walkthrough and references for application connectors and Terraform configuration.

• Create a PostgreSQL database on Google Cloud
• Manage database users and passwords
• Connect through Cloud SQL Auth Proxy

Set up automated Android builds and Google Play publishing with GitHub Actions. Supports TWA, React Native, Flutter, and native Android, with signing setup, separate testing and production tracks, and automatic build-number increments on main.

• Setting up Google Play publishing from GitHub
• Separating internal, alpha, beta, and production releases
• Automating versionCode increments on main

Build Avalonia screen logic, navigation, and step-by-step wizards using Zafiro and ReactiveUI. The skill guides ViewModels, which manage screen state and behavior, plus commands, automatic section discovery, and connections between views and their logic.

• Organizing screen state and commands in Avalonia
• Building a wizard with multiple steps
• Setting up section-based navigation

Apply consistent architecture and coding conventions when building cross-platform apps with Avalonia UI and Zafiro. The skill guides separation of interface and logic, reactive data handling, explicit error results, and reuse of existing helpers.

• Standardizing Avalonia UI and Zafiro implementation
• Keeping ViewModels independent of Avalonia
• Reviewing error handling with Result types

Turn a project idea into a detailed system plan before coding. Organize architecture, data flows, dependencies, and file-level tasks in a linked Markdown workspace, with research references, consistency checks, and saved state for resuming later.

• Plan a new system before writing code
• Break implementation into tasks with files and dependencies
• Check a design for gaps and contradictions