Development skills

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

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 GraphQL APIs with clear data types, efficient data retrieval, and example operations. Build combined APIs across services and real-time updates, while addressing repeated database requests, query cost limits, and access control for individual fields.

• Designing a new GraphQL schema
• Combining services with Apollo Federation
• Building real-time subscriptions

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

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

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

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

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

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

Review code changes and files for bugs, security risks, performance problems, design issues, and test coverage. Receive a structured report with prioritized findings, concrete improvement examples, positive feedback, and an overall review verdict.

• Reviewing a pull request
• Auditing code quality and security
• Finding refactoring opportunities

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 and debug mobile apps for iOS and Android with React Native and Expo. Implement navigation, adapt screens to each platform, integrate native modules that access platform features, and improve list rendering, keyboard behavior, and memory use.

• Building an app for both iOS and Android
• Adding tabs, navigation stacks, and deep links
• Improving scrolling performance in long lists

Build Angular 17+ applications with standalone components, routing, and shared application state. Covers reactive data handling with RxJS, performance improvements, and unit and integration tests, with code and explanations of architecture choices.

• Building Angular screens with standalone components
• Managing shared application state with NgRx
• Configuring lazy-loaded routes and access guards

Design systems made of independently deployable services, or plan how to split an existing application. The skill produces service boundary diagrams and recommendations for communication, data ownership, failure handling, monitoring, and deployment.

• Planning how to split a monolithic application
• Choosing REST, gRPC, or event-based communication
• Defining data ownership and cross-service consistency

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

Build and debug Java applications with Spring Boot 3.x. This skill guides application design, API implementation, database query tuning, authentication, and testing, including WebFlux applications that process requests without blocking.

• Build APIs with Spring Boot
• Improve slow JPA queries
• Configure OAuth2/JWT authentication

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

Configure Django file storage on AWS S3 using django-storages and boto3. Separate public and private files, create temporary download or upload links, configure CloudFront delivery, and test storage behavior without accessing real S3 buckets.

• Moving Django static files and uploads to S3
• Separating public files from private documents
• Creating temporary download and direct upload links

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

Build Go services and command-line tools with clear interfaces, explicit error handling, and concurrent tasks using goroutines and channels. Use pprof to investigate performance, then check behavior with benchmarks, structured test cases, fuzzing, and race detection.

• Implementing concurrent tasks with cancellation and error handling
• Building gRPC or REST services and command-line tools
• Investigating Go performance with pprof and benchmarks

Build web application features across the interface, API, and database, with authentication, input checks, and safe data handling. The skill guides technical design, implementation, error handling, and component testing in one workflow.

• Building data entry and editing forms with matching APIs
• Adding authenticated profile pages
• Designing data flows from database to interface

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