GraphQL systems can suffer from inefficient resolvers, unsafe query flexibility, and inconsistent schemas. This skill provides patterns for schemas, clients, performance, authorization, and production safeguards.

Dynamic sites make simple HTTP scraping unreliable. This skill shows how to automate Chromium with go-rod for scraping, testing, request interception, and debugging.

Dynamic websites are difficult to test and automate reliably with basic HTTP tools. This skill guides Playwright Go architecture, logging, cleanup, timeouts, and browser interactions.

Godot projects can become hard to maintain when gameplay logic spreads across scenes. This skill gives Claude, Codex, and Claude Code reusable GDScript patterns for cleaner game systems.

Complex Go services require careful concurrency, architecture, testing, and performance decisions. This skill provides focused guidance for maintainable Go 1.21+ systems.

Godot 3 projects often fail after upgrading because GDScript syntax and engine APIs changed. This skill maps common Godot 3 patterns to Godot 4 replacements.

Concurrent Go code can leak goroutines, deadlock, or mishandle cancellation. This skill provides production patterns for worker pools, pipelines, synchronization, and graceful shutdown.

Large or unclear pull requests slow reviews and hide important risks. This skill creates structured descriptions, checklists, risk assessments, and split recommendations from change context.

Unstructured bug reports slow triage and omit critical details. This skill converts logs, notes, screenshots, and dictation into structured GitHub issue markdown.

Gemini API projects can fail when model names, SDKs, and documentation paths change. This skill provides focused guidance for SDK setup, model selection, examples, and official references.

Game projects require many connected platform and specialty decisions. This skill routes each question to concise principles for design, implementation, and optimization.

Complex features require coordinated decisions across data, APIs, interfaces, tests, and operations. This skill organizes delivery into connected phases with clear outputs and validation.

Frontend teams often repeat component, state, and performance decisions without a shared reference. This skill provides concise React and Next.js patterns that guide consistent implementation.

Building consistent component files across web and native projects takes repeated design work. This skill structures components, types, styles, tests, stories, and exports.

Complex frontend work requires coordinated decisions across architecture, state, accessibility, testing, and performance. This skill provides implementation guidance for modern React and Next.js projects.

Legacy modernization can disrupt critical operations and hide integration risks. This skill structures assessment, testing, incremental replacement, rollout, and decommissioning with measurable safeguards.

Dependency upgrades often fail when teams miss breaking changes, peer conflicts, or rollback steps. This skill creates structured upgrade plans with risk checks, tests, migration steps, and recovery guidance.

Framework migrations are risky because behavior, dependencies, and tests can drift. This skill provides structured plans, examples, checks, and rollback guidance for controlled migrations.

React async state and validation often become inconsistent. This skill provides fp-ts patterns for predictable hooks, forms, data fetching, and dependency injection.

TypeScript error and null handling often becomes repetitive or unclear. This skill applies practical fp-ts patterns with readable examples and restrained functional design.