Communitygithub.com

bestagentkits/agency-skills

Habilidad de desarrollo frontend para aplicaciones React, Next.js, TypeScript y Tailwind CSS. Úsala al construir componentes React, optimizar el rendimiento de Next.js, analizar tamaños de paquetes, crear proyectos frontend, implementar accesibilidad o revisar la calidad del código frontend.

¿Qué es agency-skills?

Esta habilidad, definida en el archivo SKILL.md, está diseñada para desarrolladores e ingenieros de IA que trabajan con aplicaciones React y Next.js. Proporciona un conjunto completo de herramientas y flujos de trabajo para el desarrollo frontend moderno, que incluye scaffolding de proyectos, generación de componentes, análisis de paquetes y optimización del rendimiento. La habilidad admite generación de código tanto para componentes cliente como servidor, y se integra con TypeScript, Tailwind CSS, Storybook y pruebas. También incluye referencias detalladas sobre patrones de React (componentes compuestos, hooks personalizados, props de renderizado) y optimización de Next.js (componentes servidor vs. cliente, optimización de imágenes, obtención de datos). Un aspecto destacado es su enfoque en la accesibilidad (WCAG) y las pruebas, ofreciendo listas de verificación y ejemplos de código. Además, implementa el rigor disciplinario de Karpathy, exigiendo que las suposiciones del usuario (dispositivo, objetivo LCP, dependencia SEO, objetivo WCAG) se expliciten antes de hacer recomendaciones. La habilidad puede bifurcar tareas especializadas a otros agentes de IA (por ejemplo, auditoría de accesibilidad, perfilado de rendimiento) a través de un mapa de composición, lo que la convierte en una herramienta versátil para equipos frontend que buscan productividad y calidad.

Compatible con~Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/bestagentkits/agency-skills/tree/HEAD/skills/claude-skills/senior-frontend

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

Frontend Senior

Patrones de desarrollo frontend, optimización del rendimiento y herramientas de automatización para aplicaciones React/Next.js.

Tabla de Contenidos


Scaffolding de Proyectos

Genera un nuevo proyecto Next.js o React con TypeScript, Tailwind CSS y configuraciones de mejores prácticas.

Flujo de Trabajo: Crear Nuevo Proyecto Frontend

  1. Ejecuta el scaffolder con el nombre de tu proyecto y la plantilla:

    python scripts/frontend_scaffolder.py my-app --template nextjs
    
  2. Agrega características opcionales (auth, api, forms, testing, storybook):

    python scripts/frontend_scaffolder.py dashboard --template nextjs --features auth,api
    
  3. Navega al proyecto e instala las dependencias:

    cd my-app && npm install
    
  4. Inicia el servidor de desarrollo:

    npm run dev
    

Opciones del Scaffolder

OpciónDescripción
--template nextjsNext.js 14+ con App Router y Server Components
--template reactReact + Vite con TypeScript
--features authAgrega autenticación con NextAuth.js
--features apiAgrega React Query + cliente API
--features formsAgrega React Hook Form + validación Zod
--features testingAgrega Vitest + Testing Library
--dry-runVista previa de los archivos sin crearlos

Estructura Generada (Next.js)

my-app/
├── app/
│   ├── layout.tsx        # Layout raíz con fuentes
│   ├── page.tsx          # Página de inicio
│   ├── globals.css       # Tailwind + variables CSS
│   └── api/health/route.ts
├── components/
│   ├── ui/               # Button, Input, Card
│   └── layout/           # Header, Footer, Sidebar
├── hooks/                # useDebounce, useLocalStorage
├── lib/                  # utils (cn), constants
├── types/                # Interfaces TypeScript
├── tailwind.config.ts
├── next.config.js
└── package.json

Generación de Componentes

Genera componentes React con TypeScript, pruebas e historias de Storybook.

Flujo de Trabajo: Crear un Nuevo Componente

  1. Genera un componente cliente:

    python scripts/component_generator.py Button --dir src/components/ui
    
  2. Genera un componente servidor:

    python scripts/component_generator.py ProductCard --type server
    
  3. Genera con archivos de prueba e historia:

    python scripts/component_generator.py UserProfile --with-test --with-story
    
  4. Genera un hook personalizado:

    python scripts/component_generator.py FormValidation --type hook
    

Opciones del Generador

OpciónDescripción
--type clientComponente cliente con 'use client' (por defecto)
--type serverComponente servidor asíncrono
--type hookHook React personalizado
--with-testIncluye archivo de prueba
--with-storyIncluye historia de Storybook
--flatCrea en el directorio de salida sin subdirectorio
--dry-runVista previa sin crear archivos

Ejemplo de Componente Generado

'use client';

import { useState } from 'react';
import { cn } from '@/lib/utils';

interface ButtonProps {
  className?: string;
  children?: React.ReactNode;
}

export function Button({ className, children }: ButtonProps) {
  return (
    <div className={cn('', className)}>
      {children}
    </div>
  );
}

Análisis de Paquetes

Analiza package.json y la estructura del proyecto para oportunidades de optimización del paquete.

Flujo de Trabajo: Optimizar el Tamaño del Paquete

  1. Ejecuta el analizador en tu proyecto:

    python scripts/bundle_analyzer.py /path/to/project
    
  2. Revisa la puntuación de salud y los problemas:

    Puntuación de Salud del Paquete: 75/100 (C)
    
    DEPENDENCIAS PESADAS:
      moment (290KB)
        Alternativa: date-fns (12KB) o dayjs (2KB)
    
      lodash (71KB)
        Alternativa: lodash-es con tree-shaking
    
  3. Aplica las correcciones recomendadas reemplazando las dependencias pesadas.

  4. Vuelve a ejecutar en modo verbose para verificar los patrones de importación:

    python scripts/bundle_analyzer.py . --verbose
    

Interpretación de la Puntuación del Paquete

PuntuaciónCalificaciónAcción
90-100AEl paquete está bien optimizado
80-89BOptimizaciones menores disponibles
70-79CReemplazar dependencias pesadas
60-69DMúltiples problemas requieren atención
0-59FProblemas críticos de tamaño del paquete

Dependencias Pesadas Detectadas

El analizador identifica estos paquetes pesados comunes:

PaqueteTamañoAlternativa
moment290KBdate-fns (12KB) o dayjs (2KB)
lodash71KBlodash-es con tree-shaking
axios14KBFetch nativo o ky (3KB)
jquery87KBAPIs DOM nativas
@mui/materialGrandeshadcn/ui o Radix UI

Patrones de React

Referencia: references/react_patterns.md

Componentes Compuestos

Comparte estado entre componentes relacionados:

const Tabs = ({ children }) => {
  const [active, setActive] = useState(0);
  return (
    <TabsContext.Provider value={{ active, setActive }}>
      {children}
    </TabsContext.Provider>
  );
};

Tabs.List = TabList;
Tabs.Panel = TabPanel;

// Uso
<Tabs>
  <Tabs.List>
    <Tabs.Tab>Uno</Tabs.Tab>
    <Tabs.Tab>Dos</Tabs.Tab>
  </Tabs.List>
  <Tabs.Panel>Contenido 1</Tabs.Panel>
  <Tabs.Panel>Contenido 2</Tabs.Panel>
</Tabs>

Hooks Personalizados

Extrae lógica reutilizable:

function useDebounce<T>(value: T, delay = 500): T {
  const [debouncedValue, setDebouncedValue] = useState(value);

  useEffect(() => {
    const timer = setTimeout(() => setDebouncedValue(value), delay);
    return () => clearTimeout(timer);
  }, [value, delay]);

  return debouncedValue;
}

// Uso
const debouncedSearch = useDebounce(searchTerm, 300);

Render Props

Comparte lógica de renderizado:

function DataFetcher({ url, render }) {
  const [data, setData] = useState(null);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    fetch(url).then(r => r.json()).then(setData).finally(() => setLoading(false));
  }, [url]);

  return render({ data, loading });
}

// Uso
<DataFetcher
  url="/api/users"
  render={({ data, loading }) =>
    loading ? <Spinner /> : <UserList users={data} />
  }
/>

Optimización de Next.js

Referencia: references/nextjs_optimization_guide.md

Componentes Servidor vs. Cliente

Usa Server Components por defecto. Agrega 'use client' solo cuando necesites:

  • Manejadores de eventos (onClick, onChange)
  • Estado (useState, useReducer)
  • Efectos (useEffect)
  • APIs del navegador
// Server Component (por defecto) - sin 'use client'
async function ProductPage({ params }) {
  const product = await getProduct(params.id);  // Obtención del lado del servidor

  return (
    <div>
      <h1>{product.name}</h1>
      <AddToCartButton productId={product.id} />  {/* Componente cliente */}
    </div>
  );
}

// Client Component
'use client';
function AddToCartButton({ productId }) {
  const [adding, setAdding] = useState(false);
  return <button onClick={() => addToCart(productId)}>Agregar</button>;
}

Optimización de Imágenes

import Image from 'next/image';

// Above the fold - cargar inmediatamente
<Image
  src="/hero.jpg"
  alt="Hero"
  width={1200}
  height={600}
  priority
/>

// Imagen responsiva con fill
<div className="relative aspect-video">
  <Image
    src="/product.jpg"
    alt="Producto"
    fill
    sizes="(max-width: 768px) 100vw, 50vw"
    className="object-cover"
  />
</div>

Patrones de Obtención de Datos

// Obtención en paralelo
async function Dashboard() {
  const [user, stats] = await Promise.all([
    getUser(),
    getStats()
  ]);
  return <div>...</div>;
}

// Streaming con Suspense
async function ProductPage({ params }) {
  return (
    <div>
      <ProductDetails id={params.id} />
      <Suspense fallback={<ReviewsSkeleton />}>
        <Reviews productId={params.id} />
      </Suspense>
    </div>
  );
}

Accesibilidad y Pruebas

Referencia: references/frontend_best_practices.md

Lista de Verificación de Accesibilidad

  1. HTML Semántico: Usa elementos apropiados (<button>, <nav>, <main>)
  2. Navegación por Teclado: Todos los elementos interactivos deben ser enfocables
  3. Etiquetas ARIA: Proporciona etiquetas para iconos y widgets complejos
  4. Contraste de Color: Mínimo 4.5:1 para texto normal
  5. Indicadores de Enfoque: Estados de enfoque visibles
// Botón accesible
<button
  type="button"
  aria-label="Cerrar diálogo"
  onClick={onClose}
  className="focus-visible:ring-2 focus-visible:ring-blue-500"
>
  <XIcon aria-hidden="true" />
</button>

// Enlace de salto para usuarios de teclado
<a href="#main-content" className="sr-only focus:not-sr-only">
  Saltar al contenido principal
</a>

Estrategia de Pruebas

// Prueba de componente con React Testing Library
import { render, screen } from '@testing-library/react';
import userEvent from '@testing-library/user-event';

test('el botón desencadena una acción al hacer clic', async () => {
  const onClick = vi.fn();
  render(<Button onClick={onClick}>Haz clic</Button>);

  await userEvent.click(screen.getByRole('button'));
  expect(onClick).toHaveBeenCalledTimes(1);
});

// Prueba de accesibilidad
test('el diálogo es accesible', async () => {
  render(<Dialog open={true} title="Confirmar" />);

  expect(screen.getByRole('dialog')).toBeInTheDocument();
  expect(screen.getByRole('dialog')).toHaveAttribute('aria-labelledby');
});

Referencia Rápida

Configuración Común de Next.js

// next.config.js
const nextConfig = {
  images: {
    remotePatterns: [{ protocol: 'https', hostname: 'cdn.example.com' }],
    formats: ['image/avif', 'image/webp'],
  },
  experimental: {
    optimizePackageImports: ['lucide-react', '@heroicons/react'],
  },
};

Utilidades de Tailwind CSS

// Clases condicionales con cn()
import { cn } from '@/lib/utils';

<button className={cn(
  'px-4 py-2 rounded',
  variant === 'primary' && 'bg-blue-500 text-white',
  disabled && 'opacity-50 cursor-not-allowed'
)} />

Patrones de TypeScript

// Props con children
interface CardProps {
  className?: string;
  children: React.ReactNode;
}

// Componente genérico
interface ListProps<T> {
  items: T[];
  renderItem: (item: T) => React.ReactNode;
}

function List<T>({ items, renderItem }: ListProps<T>) {
  return <ul>{items.map(renderItem)}</ul>;
}

Recursos

  • Patrones de React: references/react_patterns.md
  • Optimización de Next.js: references/nextjs_optimization_guide.md
  • Mejores Prácticas: references/frontend_best_practices.md
  • Biblioteca forcing-question (grill de Matt Pocock): references/forcing_questions.md
  • Mapa de composición (a qué especialista bifurcar): references/composition_map.md

Suposiciones y Criterios de Éxito Verificables (disciplina Karpathy)

Antes de que esta habilidad genere un componente, recomiende un framework o audite un paquete, las siguientes cuatro suposiciones DEBEN ser presentadas.

  1. Dispositivo primario del usuario + red — móvil-4G, escritorio-fibra, Android de gama baja o red corporativa. Impulsa cada decisión de rendimiento.
  2. Objetivo LCP en milisegundos — un solo número, no "rápido". Impulsa el presupuesto del paquete y la elección de renderizado.
  3. Dependiente de SEO vs. protegido por autenticación — impulsa el renderizado (SSR/SSG/RSC vs. SPA).
  4. Objetivo WCAG + propietario de a11y nombrado — AA, AAA o mejor esfuerzo. Impulsa la inversión en a11y y las puertas de CI.

Criterios de éxito verificables (Karpathy #4) — cada recomendación debe incluir:

  • Objetivos de Core Web Vitals (LCP, INP, CLS) en p75 en el dispositivo primario
  • Un presupuesto de paquete JS por ruta en KB-gzip
  • Un piso de Lighthouse a11y + piso de rendimiento

Si no se indica alguno de estos tres, la recomendación está incompleta: regresa a Q2 de la biblioteca forcing-question.

La herramienta scripts/frontend_decision_engine.py codifica estas verificaciones: se niega a recomendar un perfil sin las cuatro entradas de suposición e imprime los umbrales verificables para el perfil coincidente.


Perfiles de Personalización

Cuatro perfiles integrados en profiles/ calibran cada recomendación:

PerfilCuándo elegirObjetivo LCP (móvil-4G p75)Presupuesto de paquete
next-app-routerSaaS orientado al cliente, SEO + dinámico, RSC-first2000ms150 KB-gzip / ruta
remix-or-sveltekitMóvil-4G primario, low-JS-first, mejora progresiva1500ms80 KB-gzip / ruta
vite-spaApp protegida por auth, escritorio/corporativo primario2500ms200 KB init + 80 KB / ruta
astro-or-staticMarketing / docs / blog, escritura casi nula, SEO crítico1200ms30 KB JS / página

Elige un perfil mediante:

python scripts/frontend_decision_engine.py \
  --primary-device mobile-4g --lcp-target-ms 2000 \
  --seo-dependent true --auth-walled false --team-size 5

La herramienta devuelve el perfil de mejor ajuste, el trade-off del segundo mejor (si está dentro del 15%), las opciones de stack, los anti-patrones a evitar en ese perfil y las puertas de CI requeridas.

Para agregar un perfil personalizado (por ejemplo, los valores predeterminados de herramientas internas de tu organización): copia profiles/vite-spa.json a profiles/<tu-organizacion>.json y ajusta constraints + success_thresholds.


Mapa de Composición

Esta habilidad NO reimplementa el alcance que pertenece a los especialistas de nivel POWERFUL. Se bifurca hacia ellos. Consulta references/composition_map.md para la tabla de enrutamiento completa. Bifurcaciones clave:

AsuntoBifurcar hacia
Auditoría WCAG, contraste, lector de pantallaengineering-team/skills/a11y-audit/
Perfilado de paquetes + rendimiento en tiempo de ejecuciónengineering/skills/performance-profiler/
Página de aterrizaje cinematográfica / narración con scrollengineering-team/skills/epic-design/
Apple HIG (iOS / macOS / visionOS)product-team/skills/apple-hig-expert/
Revisión pre-commit Karpathyengineering/karpathy-coder/
Grill de arquitectura prevueloengineering/grill-me/

El agente cs-frontend-engineer orquesta estas bifurcaciones mediante context: fork. Invócalo desde otro agente con Agent({subagent_type: "cs-frontend-engineer", prompt: "..."}) o

…

[truncado para traducción]

Individual skills in this repo

This repo contains 3 individual skills — each has its own dedicated page.

bestagentkits/agency-skills

Build immersive, cinematic 2.5D interactive websites using scroll storytelling, parallax depth, text animations, and premium scroll effects — no WebGL required. Use this skill for any web design task: landing pages, product sites, hero sections, scroll animations, parallax, sticky sections, section overlaps, floating products between sections, clip-path reveals, text that flies in from sides, words that light up on scroll, curtain drops, iris opens, card stacks, bleed typography, and any site that should feel cinematic or premium. Trigger on phrases like "make it feel alive", "Apple-style animation", "sections that overlap", "product rises between sections", "immersive", "scrollytelling", or any scroll-driven visual effect. Covers 45+ techniques across 8 categories. Always inspects, judges, and plans assets before coding. Use aggressively for ANY web design task.

bestagentkits/agency-skills

Generates high-converting landing pages as complete Next.js/React (TSX) components with Tailwind CSS. Creates hero sections, feature grids, pricing tables, FAQ accordions, testimonial blocks, and CTA sections using proven copy frameworks (PAS, AIDA, BAB). Outputs SEO meta tags, structured data, and performance-optimised code targeting Core Web Vitals (LCP < 1s, CLS < 0.1). Use when the user asks to create a landing page, marketing page, homepage, single-page site, lead capture page, campaign page, promo page, or conversion-optimised web page — or when they want to A/B test landing page variants or replace a static page with one designed to convert.

bestagentkits/agency-skills

Generates a premium single-page HTML landing page with 3D CSS animations, GSAP scroll effects, and mouse-parallax depth. Forcing intake (product + elevator pitch, audience register, brand overrides, tone) locks down positioning before any copy or markup is written, so the page reflects the actual product rather than generic boilerplate. Use whenever the user says 'landing for X', 'create a landing page', 'build a landing page', 'make a landing page for X', 'I need a web page for Y', or provides product/service details and wants a polished website. Also triggers on 'promotional page', 'product page', 'one-pager', 'web presence', 'sales page'. Outputs a single self-contained HTML file (Claude Code) or HTML artifact (Claude.ai). Supports configurable brand colors via CSS custom property overrides.

Skills relacionados