gustavo-santos-skills

Plugin gustavo-santos-skills from marketplace gustavo-santos-skills in gustavo-santos-swe/skills. Commands read from the repo's manifest — 1 month ago.

Skills (96)

• frontend-design

  Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, artifacts, posters, or applications (examples include websites, landing pages, dashboards, React components, HTML/CSS layouts, or when styling/beautify

• improve-codebase-architecture

  Scan a codebase for deepening opportunities, present them as a visual HTML report, then grill through whichever one you pick.

• resolving-merge-conflicts

  Use when you need to resolve an in-progress git merge/rebase conflict.

• ask

  Router for Goose lifecycle skills and implement stack packs. Use when unsure which skill or flow fits.

• brainstorm

  Relentless Q&A to freeze the what before a plan. Use when sharpening design; no implementation yet. Greenfield branch when empty repo, new product, or user asks greenfield.

• codebase-design

  Deep-module vocabulary (seam, depth, adapter). Use when shaping interfaces, deciding seams, or when brainstorm/implement/architecture-pass need that language.

• create-tickets

  Tracer-bullet issues with blockers, grounded in a source of truth. Use to split a plan/spec for implement; tracker or plan markdown - not a local ticket tree.

• diagnose

  Evidence-first debug to root cause, then fix and lock. Use when something is broken, flaky, or failing tests - before guessing a fix.

• documentation

  ADRs before build; ship-docs after. Use when a decision or public/ops surface needs a durable written trail.

• git-practices

  Conventional branch names and commit messages. Use when branching or committing; PR open stays in pr-raise.

• implement

  Build a named ticket/plan batch (TDD at seams, full pack load, dirty tree until local review). Use for implement/build work - not planning, ticket split, or opening a PR.

• database

  Language-agnostic database rules — modeling, integrity, indexes, transactions, schema evolution, SQL-level performance. Use when designing or changing schema, writing migrations/SQL, or reviewing data model decisions (not ORM/C# wiring).

• api-contracts

  Use when reviewing public API compatibility, OpenAPI drift, deprecation, or whether a change needs a new /api/vN — or when implement loads the dotnet pack for contract work.

• application-layer

  Use when writing or reviewing .NET use cases/handlers, DTOs, validation placement, or orchestration — or when implement loads the dotnet pack for Application code.

• async

  Use when writing or reviewing async/await, cancellation, parallelism, or sync-over-async traps in .NET — or when implement loads the dotnet pack for async code.

• background-work

  Use when adding or reviewing .NET Hangfire jobs, hosted services, in-process channels, or deferred work off the request thread — or when implement loads the dotnet pack for background work.

• caching

  Use when adding or reviewing .NET caching — HybridCache, keys, TTLs, invalidation, stampede — or when implement loads the dotnet pack for cache work.

• code-style

  Use when writing or reviewing C# style — nullable, records, var, naming, EditorConfig/analyzers — or when implement loads the dotnet pack for style work.

• configuration

  Use when adding or reviewing .NET configuration — appsettings hierarchy, env/secrets, typed options, feature toggles — or when implement loads the dotnet pack for config work.

• db-integration

  Use when writing or reviewing EF Core / .NET data access — DbContext, mappings, tracking, transactions, concurrency — or when implement loads the dotnet pack for persistence code.

• dependency-injection

  Use when registering or reviewing .NET DI lifetimes, composition-root extensions, options, typed HttpClients, or captive-dependency risks — or when implement loads the dotnet pack for DI work.

• domain-modeling

  Use when shaping C# domain types — entities, value objects, aggregates, invariants, domain events — or when implement loads the dotnet pack for domain code.

• endpoint-conventions

  Use when designing or reviewing ASP.NET HTTP endpoints — Minimal APIs/controllers, routes, QUERY, pagination, statuses, OpenAPI — or when implement loads the dotnet pack for API surface work.

• error-handling

  Use when defining or changing how .NET APIs express failures — unions/Result, error cases, HTTP mapping, exceptions vs expected outcomes.

• file-storage

  Use when adding or reviewing .NET file/blob upload download, object storage ports, size/type limits, or signed URLs — or when implement loads the dotnet pack for storage work.

• health-and-readiness

  Use when adding or reviewing ASP.NET health/readiness probes — /alive vs /health, dependency checks, timeouts, exposure — or when implement loads the dotnet pack for probe work.

• http-clients

  Use when adding or reviewing outbound .NET HTTP calls — typed clients, DelegatingHandlers, fakes — or when implement loads the dotnet pack for HttpClient work.

• messaging

  Use when designing or reviewing .NET integration events, buses, outbox, or queue consumers — or when choosing events vs Hangfire jobs — or when implement loads the dotnet pack for messaging work.

• migrations-and-compat

  Use when adding or reviewing EF Core migrations, expand/contract deploy order, or schema apply in CI — or when implement loads the dotnet pack for migration work.

• observability

  Use when adding or reviewing .NET telemetry — OpenTelemetry traces/metrics, MEL structured logging, correlation, PII rules — or when implement loads the dotnet pack for observability work.

• rate-limiting

  Use when adding or reviewing ASP.NET request throttles, per-user/IP quotas, 429 behavior, or probe exemptions — or when implement loads the dotnet pack for rate-limit work.

• resilience

  Use when designing or reviewing .NET retries, timeouts, circuit breakers, or idempotent outbound calls — Polly/standard Http resilience — or when implement loads the dotnet pack for resilience work.

• security

  Use when adding or reviewing .NET AuthN/Z, HTTPS, CORS, CSRF, trust-boundary input, or data protection — or when implement loads the dotnet pack for security work.

• serialization

  Use when configuring or reviewing .NET JSON wire format — System.Text.Json, enums, dates, DTOs vs entities — or when implement loads the dotnet pack for serialization work.

• solution-structure

  Use when changing .NET solution layout, project boundaries, references, or Directory.Build/CPM — or when implement loads the dotnet pack for where code should live.

• testing

  Use when writing or reviewing .NET tests — TUnit, NSubstitute, Testcontainers, architecture tests, naming — or when implement loads the dotnet pack for test work.

• time-and-ids

  Use when writing or reviewing clocks, UTC/calendar time, NodaTime types, or ID generation in .NET — or when implement loads the dotnet pack for time/id code.

• validation

  Use when defining or reviewing request/domain validation in .NET — FluentValidation placement, boundary vs invariants, uniqueness — or when implement loads the dotnet pack for validation work.

• web-accessibility

  Use when improving web a11y in Next.js — semantics, focus, keyboard, and ARIA.

• web-auth

  Use when implementing Next.js authentication — sessions, Auth.js/Clerk/etc., protected routes, or server auth helpers.

• web-caching-and-revalidation

  Use when setting Next.js cache tags, revalidatePath/Tag, ISR, or diagnosing stale UI after mutations.

• web-data-fetching

  Use when fetching data in Next.js — RSC fetch, cache options, Suspense, or client queries.

• web-env-and-config

  Use when adding environment variables, `NEXT_PUBLIC_*`, or runtime config in Next.js.

• web-error-loading-ui

  Use when adding Next.js `loading.tsx`, `error.tsx`, `not-found`, or Suspense fallbacks.

• web-images-fonts-assets

  Use when configuring next/image, next/font, static assets, or remote image patterns in Next.js.

• web-localization

  Use when adding Next.js i18n routing, dictionaries, or locale-aware formatting.

• web-metadata-and-seo

  Use when setting Next.js Metadata API, Open Graph, sitemaps, robots, or JSON-LD.

• web-middleware

  Use when adding or changing Next.js middleware (auth redirects, headers, geo, A/B gates).

• web-performance

  Use when improving Next.js Core Web Vitals, bundle size, streaming, or client JS weight.

• web-project-structure

  Use when laying out or changing a Next.js App Router repo (folders, feature modules, shared UI kit, or monorepo boundaries), or when implement loads the frontend pack for where code should live.

• web-route-handlers

  Use when adding Next.js Route Handlers (`app/api`) or webhook endpoints.

• web-routing-and-layouts

  Use when adding Next.js routes, layouts, parallel/intercepting routes, or navigational UX.

• web-server-actions-and-forms

  Use when implementing Next.js Server Actions, progressive forms, or progressive enhancement for mutations.

• web-server-and-client

  Use when deciding RSC vs client components, `'use client'` boundaries, or shipping JS to the browser in Next.js.

• web-state-client

  Use when adding client-only state (Zustand, context, URL state) in Next.js client islands.

• web-styling

  Use when styling Next.js UI (tokens, Tailwind, CVA variants, DESIGN.md, or reuse of shared primitives), or when implement loads the frontend pack for style work.

• web-typescript-conventions

  Use when setting TS patterns for a Next.js/React codebase — types for props, zod boundaries, and strictness.

• rn-animations

  Use when adding Reanimated/Skia motion in React Native — Goose defaults; deep patterns may defer to mobile area skills.

• rn-auth-and-secure-storage

  Use when implementing login sessions, tokens, biometrics, or secure storage in React Native / Expo.

• rn-deep-linking

  Use when configuring Universal Links / App Links, Expo linking, or in-app deep link routing.

• rn-error-and-boundaries

  Use when defining error UI, ErrorBoundaries, crash reporting, or user-visible failure patterns in React Native.

• rn-forms-and-inputs

  Use when building React Native forms, text inputs, keyboard handling, or client-side validation UX.

• rn-gestures

  Use when implementing pan/pinch/swipe/long-press or Gesture Handler patterns in React Native.

• rn-images-and-media

  Use when loading images, picking photos/files, or playing media in React Native / Expo.

• rn-lists-and-virtualization

  Use when building FlashList/FlatList feeds, infinite scroll, or list performance work in React Native.

• rn-native-modules

  Use when adding Expo modules, config plugins, or custom native iOS/Android code to a React Native app.

• rn-navigation

  Use when adding or changing Expo Router / React Navigation stacks, tabs, modals, or auth gates in React Native.

• rn-offline-and-sync

  Use when designing offline-first behavior, mutation queues, or sync conflict handling in React Native.

• rn-push-notifications

  Use when adding Expo notifications, FCM/APNs, channels, or notification tap routing in React Native.

• rn-state-management

  Use when choosing or changing client state (server cache, Zustand/context, form state) in a React Native app.

• rn-theming

  Use when adding dark mode, brand themes, or dynamic color schemes in a React Native / Expo app.

• planning

  Actionable implementation plan (tasks, files, verify) - no feature code. Use when the what is frozen and you need the how.

• pr-iterate
• pr-raise
• pr-review
• research
• security-check
• verify
• write-like-goose
• evolve-goose-skills
• skill-retro
• suggesting-skills
• teach
• writing-great-skills
• react-native-best-practices
• audio
• jsi
• multithreading
• on-device-ai
• rich-text
• svg
• react-native-design
• react-native-performance
• react-native-styling-and-navigation
• ui-ux-pro-max
• doc-coauthoring

Similar plugins