Jeffallan

Adapt large language models to specific tasks through fine-tuning, or additional training. Prepares and validates datasets, configures LoRA or QLoRA to train a small subset of parameters, and supplies training settings, evaluation scripts, and deployment optimization guidance.

• Preparing and validating JSONL training data
• Choosing LoRA or QLoRA for available GPU memory
• Configuring training and monitoring overfitting

Build Next.js 14+ applications with App Router, server-rendered components, and form actions. Produces routes, page layouts, data fetching, loading and error states, and SEO metadata, while supporting performance optimization and deployment preparation.

• Building pages and layouts with App Router
• Implementing form submissions with Server Actions
• Adding loading states, error handling, and SEO metadata

Design REST or GraphQL APIs by defining data relationships, requests, responses, and authentication. Produce OpenAPI specifications, machine-readable API descriptions, with consistent errors, pagination, and versioning plans, then validate contracts using a mock server.

• Designing a new API from business requirements
• Creating and validating OpenAPI specifications
• Standardizing errors and paginated responses

Design controlled failure experiments for distributed systems to examine how services recover. Produce failure injection scripts, monitoring plans, rollback procedures, and exercise guides, then turn findings into documented improvements.

• Planning controlled failure experiments
• Testing recovery after Kubernetes Pod failures
• Checking service behavior under network delays

Design cloud architectures and migration plans for AWS, Azure, and GCP. Produce service diagrams, selection rationale, security designs, cost estimates, and recovery strategies, with deployment and rollback plans that account for availability and operational monitoring.

• Design a cloud architecture and explain service choices
• Plan a cloud migration and cutover checks
• Review cloud spending and resource sizes

Write and refactor C++20/23 applications, addressing memory management, concurrency, and performance bottlenecks. Produce interfaces, implementations, tests, and relevant CMake updates, then check runtime errors and measure performance before applying targeted optimizations.

• Refactoring existing code with C++20/23 features
• Investigating memory errors and undefined behavior
• Improving performance through profiling and benchmarks

Investigate slow PostgreSQL and MySQL queries using execution plans, which show how the database runs a query. Develop index, SQL, and configuration changes, then compare measurements before and after each change to validate the results.

• Investigating slow SQL queries
• Reviewing database index design
• Tuning memory and database configuration

Build Django web applications and REST APIs with Django REST Framework. This skill guides data models, input validation, views, authentication, permissions, and tests, while improving how applications retrieve related records from the database.

• Build a REST API with Django
• Design data models and relationships
• Reduce database queries for related records

Develop microcontroller firmware for STM32 or ESP32, including peripheral drivers and FreeRTOS tasks. The skill guides interrupt handling, memory and power optimization, and checks that time-sensitive operations meet their deadlines.

• Implementing peripheral control on STM32 or ESP32
• Designing periodic tasks and synchronization with FreeRTOS
• Reducing firmware memory use and power consumption

Build Python APIs with FastAPI and Pydantic V2, including input validation, database operations that avoid blocking other work, and token-based authentication. Implement REST or WebSocket endpoints, then check their behavior with automated tests and generated API documentation.

• Build REST APIs with FastAPI
• Validate input data with Pydantic V2
• Implement JWT authentication and authorization

Turn a feature idea into a specification through structured questions about users, business goals, and technical constraints. Produce requirements, user stories, testable acceptance criteria, and an implementation checklist, including performance, security, and error handling.

• Defining requirements for a new feature
• Clarifying vague feature requests
• Writing testable acceptance criteria

Build cross-platform apps with Flutter and Dart, from reusable interface components to state management and navigation. The skill covers Riverpod or Bloc, GoRouter routing, automated tests, and profiling to reduce stuttering and unnecessary screen updates.

• Building reusable Flutter widgets and animations
• Managing application state with Riverpod or Bloc
• Setting up navigation and deep links with GoRouter

Build game systems in Unity or Unreal Engine, including physics, AI, and multiplayer networking. The skill guides architecture, implementation, profiling, and testing to work toward frame rate targets and reduce memory use.

• Implementing game mechanics in Unity or Unreal Engine
• Reducing frame drops and memory use
• Building multiplayer networking with lag compensation

Implement Kotlin applications with asynchronous tasks, shared code across platforms, Android interfaces, and servers. The skill covers state modeling, cancellation handling, tests, and code checks, with guidance for Compose, Ktor, and Flow data streams.

• Implement asynchronous tasks with coroutines and Flow
• Design shared code for Kotlin Multiplatform
• Build Android interfaces with Jetpack Compose

Create Kubernetes deployment files and Helm charts, reusable application packages. Configure permissions, network isolation, and persistent storage, then investigate pod failures and resource usage to adjust workloads and verify deployment health.

• Create deployment YAML and Helm charts
• Configure access permissions and network isolation
• Set up persistent storage and sensitive configuration

Build Laravel applications with authenticated APIs, interactive interfaces, and background jobs. The skill guides database relationships, query optimization, and feature tests, using tools such as Sanctum for authentication and Livewire for interfaces.

• Build an authenticated Laravel API
• Optimize database queries and relationships
• Set up background jobs with Horizon

Build MCP servers and clients that connect AI systems to external tools and data. The skill defines validated inputs, implements tool and resource handlers, configures communication methods, and checks protocol behavior with the MCP Inspector.

• Expose external tools and data to AI systems through MCP
• Start an MCP project in TypeScript or Python
• Validate inputs and investigate protocol errors

Set up application monitoring with structured logs, performance metrics, and traces that follow requests across services. Build dashboards and alerts, run load tests, investigate CPU and memory bottlenecks, and estimate future infrastructure capacity.

• Set up application dashboards and alerts
• Investigate production issues using logs, metrics, and traces
• Run load tests before traffic increases

Build PHP 8.3+ applications with Laravel or Symfony, including typed models, services, APIs, and tests. Use static analysis, which checks code without running it, alongside automated tests to verify the implementation.

• Building APIs with Laravel or Symfony
• Separating business logic from controllers
• Creating typed data objects and domain models

Build machine learning workflows that connect data checks, training, evaluation, and deployment. The skill implements experiment tracking, model version management, and automated retraining, with reproducible environments and explicit validation thresholds before models enter production.

• Automate model training and retraining workflows
• Record and compare machine learning experiments
• Build a feature store for model input data

Build Rails 7+ applications with partial page updates, real-time connections, and background jobs. The skill implements Hotwire, Action Cable, and Sidekiq features, improves Active Record database queries, and writes RSpec tests.

• Adding partial page updates with Hotwire
• Building real-time features with Action Cable
• Moving slow tasks to Sidekiq jobs

Design or review a system’s overall structure, compare technology choices, and plan for growth and failures. Produce architecture diagrams and Architecture Decision Records, documents that explain key choices, alternatives, and their consequences.

• Designing the overall structure of a new system
• Comparing monolith and microservices architectures
• Recording technology decisions and alternatives

Design and implement command-line tools with subcommands, options, interactive prompts, and progress indicators. Get command structures, configuration handling, clear error messages, and shell completion scripts, with guidance for automated use and testing across operating systems.

• Build a command-line tool with subcommands and options
• Add interactive prompts and progress indicators
• Provide bash, zsh, and fish command completion

Build C# applications with .NET 8+, including ASP.NET Core APIs and Blazor interfaces. Get models, endpoints, services, and configuration, with guidance on database access, asynchronous operations, cancellation, authentication, performance tuning, and tests.

• Build a REST API with ASP.NET Core
• Implement database access with Entity Framework Core
• Create Blazor components and manage application state