frontend-integration
Skill28 starsChanged 3 months agoApache-2.0View on GitHub
Implementa interfaces e integra o frontend com APIs e estados. Trigger em: "React", "Next.js", "componente", "página", "Zustand", "React Query", "TanStack Query", "skeleton", "loading", "hook", "frontend", "integração", "mobile responsive", "Tailwind", "formulário", "roteamento".
- Reads credentials
1 other project uses a version of this.
Adopted by
Most recently taken up by
- terrene-foundation/pacttheir own version, first seen Apr 6, 2026
Other versions1 project uses a version of this.
Word for word · 0
None found.
Edited · 0
None found.
Wrote their own version · 1
- terrene-foundation/pact★ 0same name
How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.
In this repository92 other files it gives its agents.
- AGENTS.mdAGENTS.md
- CLAUDE.mdCLAUDE.md
- po-feature-specSkill
- ui-ux-designSkill
- backend-apiSkill
- qa-testingSkill
- security-reviewSkill
- deploy-dockerSkill
- context-managerSkill
- orchestratorSkill
- documenterSkill
- reviewerSkill
- motion-designSkill
- marketing-copySkill
- seo-specialistSkill
- mobile-tauriSkill
- image-generatorSkill
- repo-auditorSkill
- asset-librarianSkill
- observability-sreSkill
- data-analyticsSkill
- accessibility-specialistSkill
- migration-refactor-specialistSkill
- release-managerSkill
- ai-integration-architectSkill
- prompt-engineerSkill
- video-integration-specialistSkill
- claude-md-generatorSkill
- design-intelligenceSkill
- cost-trackerSkill
- session-summarySkill
- smart-suggestionsSkill
- detective-specSkill
- static-analysisSkill
- skill-authorSkill
- web-asset-generatorSkill
- tdd-engineerSkill
- architecture-deepenerSkill
- program-routerSkill
- parallel-dispatcherSkill
- blog-publisherSkill
- blog-screenshotSkill
- canary-deploymentSkill
- zoom-outSkill
- handoff-contextSkill
- post-deploy-canary-monitorSkill
- pattern-conformitySkill
- research-prepSkill
- context-budgetSkill
- direct-response-copySkill
- ux-researchSkill
- ui-polishSkill
- doubt-driven-reviewSkill
- video-analysisSkill
- marketing-reporting-analyticsSkill
- responsive-conversionSkill
- mobile-ux-foundationsSkill
- i18n-localizationSkill
- closed-loop-revenueSkill
- app-reference-architectureSkill
- The first 60 shown.
The file
We split this skill into the rules it gives an agent
2 rules. About 0 are common, 0 are distinctive, and 2 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈0
Distinctive · estimate
This author's own choices. Worth a look.
2
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Very specific: line 86
No App Router do Next.js, prefira Server Components para conteudo sem interacao e mantenha use client na menor subarvore interativa …
- Very specific: line 87
Use Suspense para liberar partes independentes da pagina enquanto dados nao criticos chegam.
≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Frontend Developer - React/Next.js + Zustand + React Query
O Frontend transforma design em codigo, integrando com a API e garantindo UX fluida.
Governanca Global
Esta skill segue GLOBAL.md, policies/execution.md, policies/handoffs.md, policies/quality-gates.md, policies/token-efficiency.md, policies/stack-flexibility.md, policies/tool-safety.md e policies/evals.md.
Para snippets extensos e exemplos completos, consultar docs/skill-guides/frontend-integration.md apenas quando a tarefa exigir.
Para integracoes locais de MCP com bibliotecas visuais, consultar docs/skill-guides/ui-component-mcps.md.
Ao criar ou redesenhar um app, site ou landing de ponta a ponta, 92-design-director mantém a direção de UX/UI; esta skill implementa a interface e suas integrações.
Ao alterar mídia ou recursos da página, reserve dimensões e investigue prioridade e scripts conforme o contexto. Identifique o elemento de LCP por medição antes de priorizá-lo e não afirme melhoria de desempenho sem dados; consulte skills/91-unslop/references/evidencia-web.md quando aplicável.
Quando a tarefa exigir navegacao real, screenshots ou verificacao visual do app rodando, esta skill pode configurar ou reutilizar Playwright MCP localmente.
Quando Usar
- implementar tela, componente, estado ou integracao com API
- fechar comportamento de loading, erro, vazio e refresh
Quando Nao Usar
- para definir regras de negocio sem apoio do Backend ou PO
- para motion, SEO ou review final como atividade principal
Entradas Esperadas
- spec do PO e direcao de UI/UX
- contrato de API
- restricoes de estado, auth e navegacao
Saidas Esperadas
- interface funcional integrada
- estados de UX tratados
- handoff claro para QA
Para auth, o access token fica apenas em memoria. Persistencia local fica reservada a preferencias nao sensiveis, nunca a tokens.
Responsabilidades
- Implementar interfaces conforme spec do UI/UX
- Integrar com APIs usando React Query
- Gerenciar estado global com Zustand
- Implementar skeleton loading em toda tela com fetch
- Garantir responsividade mobile-first
- Código limpo, DRY, e tipado
Stack e Estrutura
Stack de referencia:
- React ou Next.js
- Zustand para estado global quando necessario
- React Query para server state
- Axios ou cliente HTTP equivalente
- TypeScript strict mode
Para estrutura de pastas e exemplos completos de store, auth e API client, consultar docs/skill-guides/frontend-integration.md.
Padroes Principais
- estado global pequeno e focado em UI ou sessao
accessTokenapenas em memoria- server state separado do estado local
- estados de loading, erro, vazio e retry definidos por tela
Performance em React e Next.js
Ao implementar ou revisar uma tela, priorize gargalos percebidos pelo usuario: cascatas de rede, JavaScript enviado ao navegador e trabalho repetido de renderizacao. Primeiro identifique o caminho lento; aplique memoizacao ou outras otimizacoes locais somente quando o perfil ou o comportamento observado justificar.
Dados e renderizacao no servidor
- Inicie em paralelo buscas independentes com
Promise.all; para dependencias parciais, comece cada busca assim que seus dados de entrada estiverem disponiveis. Mantenha sequencial apenas o que realmente depende do resultado anterior. - Adie
awaitpara o ramo que usa o resultado e verifique condicoes locais baratas antes de iniciar operacoes remotas que talvez sejam desnecessarias. - No App Router do Next.js, prefira Server Components para conteudo sem interacao e mantenha
use clientna menor subarvore interativa possivel. Passe para componentes de cliente apenas os dados que eles precisam. - Use
Suspensepara liberar partes independentes da pagina enquanto dados nao criticos chegam. Mantenha o fallback com dimensoes proximas ao conteudo e nao atrase conteudo essencial para SEO ou decisoes de layout. - Em SSR/RSC, nao guarde dados especificos de uma requisicao em variaveis mutaveis no escopo do modulo; isso pode misturar estado entre requisicoes.
const [profile, notifications] = await Promise.all([
getProfile(userId),
getNotifications(userId),
]);Bundle e fronteiras de cliente
- Prefira importar diretamente o modulo usado quando uma biblioteca expoe um barrel pesado e o bundler nao consegue remover reexportacoes nao usadas.
- Carregue componentes grandes e pouco frequentes sob demanda; mantenha bibliotecas de analytics e outros terceiros nao essenciais fora do caminho inicial quando a integracao permitir.
- Coloque estado e assinaturas perto do componente que os consome para evitar rerenderizar subarvores amplas. Para estado derivado e efeitos que apenas sincronizam estado React, consulte a skill
79-react-useeffect-review. - Nao adicione
memo,useMemoouuseCallbackpor padrao: primeiro confirme que ha trabalho caro ou renderizacao repetida relevante. Para interacoes caras que bloqueiam a entrada, avaliestartTransitionouuseDeferredValue.
Ao aplicar uma otimizacao, preserve comportamento, acessibilidade e estabilidade visual; confirme o efeito com profiling ou comparacao do bundle quando o projeto oferecer essas ferramentas.
Storage Client-Side Reativo
Para persistir preferencia de UI, filtro de tela ou qualquer estado nao sensivel que precisa sobreviver a reload ou sincronizar entre abas, o default e o middleware persist do Zustand (zustand/middleware) quando o projeto ja usa Zustand para esse estado — nao adicionar dependencia nova so pra isso.
brownies (https://github.com/franciscop/brownies, MIT, npm brownies) e uma opcao pontual quando nao ha Zustand no caminho: cookie/local/session/db com interface unificada de getter/setter direto (nao .get()/.set()) e sincronizacao entre abas via subscribe().
import { cookies, local, session, db, subscribe, unsubscribe } from 'brownies';
local.token = 42; // set
const t = local.token; // get (sincrono para cookies/local/session)
delete local.token; // remove
// db (IndexedDB) e assincrono
db.token = 42;
const dbVal = await db.token;
// subscribe reage a mudanca feita em outra aba ou via API nativa
const id = subscribe(local, 'points', (value) => setPoints(value));
unsubscribe(id); // ou unsubscribe(callback)Quando usar: state simples fora de um store existente — ex. tela isolada sem Zustand, ou precisa de cookies/session/db (IndexedDB) alem de localStorage, o que persist do Zustand nao cobre nativamente.
Quando nao usar: projeto ja tem Zustand no estado que precisa persistir — nesse caso persist resolve sem dependencia nova. Tambem nao usar para dado sensivel (token, PII) — regra desta skill de token apenas em memoria continua valendo, brownies nao muda isso.
Gap de baixa prioridade: e o caso mais "commodity" entre as libs avaliadas para esta skill — a maior parte dos projetos ja resolve isso com persist, entao tratar como nota, nao como recomendacao forte.
MCPs de Componentes
Esta skill pode instalar ou configurar localmente MCPs de bibliotecas como Magic UI MCP e React Bits MCP quando isso acelerar a implementacao e o projeto nao tiver equivalente melhor.
Regras:
- verificar se o MCP ja existe antes de configurar outro
- adaptar componentes ao design system do app
- nao introduzir visual ou motion que destoem do produto
- registrar a instalacao/configuracao local no handoff quando houver mudanca no workspace
Biblioteca de Componentes para Apps Document-Heavy
Quando a feature envolve visualizar ou manipular documentos dentro do app (PDF, DOCX, XLSX, CSV, upload com preview, citação com bounding box sobre o documento, e-signing, schema builder), considerar extend-hq/ui (https://github.com/extend-hq/ui, MIT) em vez de construir viewer do zero ou improvisar com libs genéricas.
Componentes principais do kit: PDF viewer (baseado em react-pdf), DOCX viewer, XLSX viewer, file upload, file thumbnail, e-signature, layout blocks (inspeção de OCR com confidence score), bounding box citations (citação campo a campo com diff em JSON), file system/finder (visões ícone, lista, coluna, galeria).
Stack esperada: React + TypeScript, Tailwind CSS, primitivas shadcn/ui (Button, Select, Dialog, ScrollArea, Tooltip precisam existir no projeto). Next.js não é obrigatório para os componentes em si — é usado no site de docs do projeto original. Instalação é via shadcn CLI, componente por componente, como código-fonte copiado para o projeto (não é dependência de pacote fechada):
npx shadcn@latest add @extend/pdf-viewerQuando usar: o produto já tem (ou vai ter) fluxo de revisão/anotação de documentos — contratos, notas fiscais, planilhas importadas, formulários assinados — e precisa de viewer com citação/bounding box ou e-signing nativo.
Quando não usar: telas sem documento nenhum (CRUD comum, dashboards, formulários simples) — nesse caso os componentes de MCPs de Componentes acima (Magic UI, React Bits) resolvem melhor. Também não usar se o projeto não tiver shadcn/ui configurado e não quiser adotar — nesse caso o custo de introduzir a dependência de primitivas supera o ganho.
MCP de Browser
Para validacao visual real, esta skill pode usar Playwright MCP para:
- abrir o app localmente
- navegar por telas e fluxos
- verificar comportamento responsivo
- capturar screenshots para confirmar detalhes de UI
Usar especialmente quando a mudanca visual nao puder ser validada com confianca apenas por leitura de codigo.
Para exemplos completos de store, authStore, uiStore e api client, consultar docs/skill-guides/frontend-integration.md.
React Query - Padrão de Hooks
src/lib/query-keys.ts
export const queryKeys = {
users: {
all: ['users'] as const,
lists: () => [...queryKeys.users.all, 'list'] as const,
list: (params: Record<string, unknown>) => [...queryKeys.users.lists(), params] as const,
details: () => [...queryKeys.users.all, 'detail'] as const,
detail: (id: string) => [...queryKeys.users.details(), id] as const,
},
posts: {
all: ['posts'] as const,
lists: () => [...queryKeys.posts.all, 'list'] as const,
list: (params: Record<string, unknown>) => [...queryKeys.posts.lists(), params] as const,
details: () => [...queryKeys.posts.all, 'detail'] as const,
detail: (id: string) => [...queryKeys.posts.details(), id] as const,
},
} as const;src/hooks/useApi.ts
import { useQuery, useMutation, useQueryClient, UseQueryOptions } from '@tanstack/react-query';
import { api } from '@/lib/api-client';
import type { ApiResponse, PaginatedResponse } from '@/types/api';
export function usePaginatedQuery<T>(
queryKey: readonly unknown[],
url: string,
params?: Record<string, unknown>,
options?: Omit<UseQueryOptions, 'queryKey' | 'queryFn'>
) {
return useQuery({
queryKey: [...queryKey, params],
queryFn: async () => {
const { data } = await api.get<PaginatedResponse<T>>(url, { params });
return data;
},
placeholderData: (prev) => prev,
...options,
});
}
export function useDetailQuery<T>(
queryKey: readonly unknown[],
url: string,
options?: Omit<UseQueryOptions, 'queryKey' | 'queryFn'>
) {
return useQuery({
queryKey,
queryFn: async () => {
const { data } = await api.get<ApiResponse<T>>(url);
return data.data;
},
...options,
});
}
export function useApiMutation<TInput, TOutput = unknown>(
method: 'post' | 'patch' | 'delete',
url: string | ((variables: TInput) => string),
options?: {
invalidateKeys?: readonly unknown[][];
onSuccess?: (data: TOutput) => void;
optimistic?: {
queryKey: readonly unknown[];
updater: (old: any, variables: TInput) => any;
};
}
) {
const queryClient = useQueryClient();
return useMutation({
mutationFn: async (variables: TInput) => {
const endpoint = typeof url === 'function' ? url(variables) : url;
const { data } = await api[method]<ApiResponse<TOutput>>(endpoint, variables);
return data.data;
},
onMutate: options?.optimistic
? async (variables) => {
await queryClient.cancelQueries({ queryKey: options.optimistic!.queryKey });
const previous = queryClient.getQueryData(options.optimistic!.queryKey);
queryClient.setQueryData(
options.optimistic!.queryKey,
(old: any) => options.optimistic!.updater(old, variables)
);
return { previous };
}
: undefined,
onError: options?.optimistic
? (err, variables, context: any) => {
queryClient.setQueryData(options.optimistic!.queryKey, context?.previous);
}
: undefined,
onSuccess: (data) => {
options?.invalidateKeys?.forEach((key) => {
queryClient.invalidateQueries({ queryKey: key });
});
options?.onSuccess?.(data);
},
});
}Checkpoint antes de considerar a integração pronta: para toda mutation com optimistic, forçar o backend a retornar erro (mockar 500, ou desligar o endpoint temporariamente) e confirmar que a UI reverte pro estado anterior — não só que o optimistic update aparece no caminho feliz. Se o rollback não reverter visualmente, o previous capturado em onMutate está errado (query key diferente da que o updater mexeu) — corrigir a query key e repetir o teste de erro forçado antes de seguir.
Skeleton Loading - Implementação
src/components/ui/Skeleton.tsx
import { cn } from '@/lib/utils';
interface SkeletonProps {
className?: string;
variant?: 'text' | 'circular' | 'rectangular';
width?: string | number;
height?: string | number;
lines?: number;
}
export function Skeleton({ className, variant = 'text', width, height, lines = 1 }: SkeletonProps) {
const baseClass = 'animate-pulse bg-gray-200 rounded';
if (variant === 'circular') {
return (
<div
className={cn(baseClass, 'rounded-full', className)}
style={{ width: width || 40, height: height || 40 }}
/>
);
}
if (variant === 'rectangular') {
return (
<div
className={cn(baseClass, className)}
style={{ width: width || '100%', height: height || 200 }}
/>
);
}
return (
<div className="space-y-2">
{Array.from({ length: lines }).map((_, i) => (
<div
key={i}
className={cn(baseClass, 'h-4', className)}
style={{
width: i === lines - 1 ? '60%' : i % 2 === 0 ? '100%' : '80%',
}}
/>
))}
</div>
);
}
export function withSkeleton<T>(
Component: React.ComponentType<T>,
SkeletonComponent: React.ComponentType
) {
return function SkeletonWrapper({ isLoading, ...props }: T & { isLoading: boolean }) {
if (isLoading) return <SkeletonComponent />;
return <Component {...(props as T)} />;
};
}src/components/skeletons/UserListSkeleton.tsx
import { Skeleton } from '@/components/ui/Skeleton';
export function UserListSkeleton({ count = 5 }: { count?: number }) {
return (
<div className="space-y-4">
{Array.from({ length: count }).map((_, i) => (
<div key={i} className="flex items-center gap-4 p-4 border rounded-lg">
<Skeleton variant="circular" width={48} height={48} />
<div className="flex-1 space-y-2">
<Skeleton className="h-4 w-1/3" />
<Skeleton className="h-3 w-1/2" />
</div>
<Skeleton className="h-8 w-20" variant="rectangular" />
</div>
))}
</div>
);
}API Client - Axios com Interceptors
src/lib/api-client.ts
import axios from 'axios';
import { useAuthStore } from '@/stores/authStore';
export const api = axios.create({
baseURL: process.env.NEXT_PUBLIC_API_URL,
timeout: 10000,
withCredentials: true,
headers: { 'Content-Type': 'application/json' },
});
api.interceptors.request.use((config) => {
const token = useAuthStore.getState().accessToken;
if (token) {
config.headers.Authorization = `Bearer ${token}`;
}
const csrfToken = getCookie('csrf-token');
if (csrfToken) {
config.headers['X-CSRF-Token'] = csrfToken;
}
return config;
});
let isRefreshing = false;
let failedQueue: Array<{ resolve: Function; reject: Function }> = [];
const processQueue = (error: any, token: string | null) => {
failedQueue.forEach((prom) => {
if (error) prom.reject(error);
else prom.resolve(token);
});
failedQueue = [];
};
api.interceptors.response.use(
(response) => response,
async (error) => {
const originalRequest = error.config;
if (error.response?.status === 401 && !originalRequest._retry) {
if (isRefreshing) {
return new Promise((resolve, reject) => {
failedQueue.push({ resolve, reject });
}).then((token) => {
originalRequest.headers.Authorization = `Bearer ${token}`;
return api(originalRequest);
});
}
originalRequest._retry = true;
isRefreshing = true;
try {
const { data } = await axios.post(
`${process.env.NEXT_PUBLIC_API_URL}/auth/refresh`,
{},
{ withCredentials: true }
);
const { accessToken, user } = data.data;
useAuthStore.getState().setAuth(user, accessToken);
processQueue(null, accessToken);
originalRequest.headers.Authorization = `Bearer ${accessToken}`;
return api(originalRequest);
} catch (refreshError) {
processQueue(refreshError, null);
useAuthStore.getState().clearAuth();
if (typeof window !== 'undefined') window.location.href = '/login';
return Promise.reject(refreshError);
} finally {
isRefreshing = false;
}
}
return Promise.reject(error);
}
);
function getCookie(name: string): string | null {
if (typeof document === 'undefined') return null;
const match = document.cookie.match(new RegExp(`(^| )${name}=([^;]+)`));
return match ? match[2] : null;
}Providers Setup
src/app/providers.tsx
'use client';
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
import { ReactQueryDevtools } from '@tanstack/react-query-devtools';
import { useState, type ReactNode } from 'react';
export function Providers({ children }: { children: ReactNode }) {
const [queryClient] = useState(
() =>
new QueryClient({
defaultOptions: {
queries: {
staleTime: 60 * 1000,
gcTime: 5 * 60 * 1000,
retry: 1,
refetchOnWindowFocus: false,
},
mutations: {
retry: 0,
},
},
})
);
return (
<QueryClientProvider client={queryClient}>
{children}
{process.env.NODE_ENV === 'development' && <ReactQueryDevtools />}
</QueryClientProvider>
);
}Exemplo Completo - Listagem com Skeleton
src/app/(dashboard)/users/page.tsx
'use client';
import { useState } from 'react';
import { usePaginatedQuery } from '@/hooks/useApi';
import { queryKeys } from '@/lib/query-keys';
import { UserListSkeleton } from '@/components/skeletons/UserListSkeleton';
import { UserCard } from '@/components/features/UserCard';
import { Pagination } from '@/components/ui/Pagination';
import { SearchInput } from '@/components/ui/SearchInput';
import { useDebounce } from '@/hooks/useDebounce';
import type { User } from '@/types/user';
export default function UsersPage() {
const [page, setPage] = useState(1);
const [search, setSearch] = useState('');
const debouncedSearch = useDebounce(search, 300);
const params = { page, perPage: 20, search: debouncedSearch };
const { data, isLoading, isError, error } = usePaginatedQuery<User>(
queryKeys.users.list(params),
'/api/v1/users',
params
);
return (
<div className="space-y-6">
<div className="flex flex-col sm:flex-row justify-between gap-4">
<h1 className="text-2xl font-bold">Usuários</h1>
<SearchInput
value={search}
onChange={setSearch}
placeholder="Buscar usuários..."
/>
</div>
{isLoading ? (
<UserListSkeleton count={5} />
) : isError ? (
<ErrorState message={error.message} onRetry={() => {}} />
) : data?.data.length === 0 ? (
<EmptyState message="Nenhum usuário encontrado" />
) : (
<>
<div className="grid gap-4 sm:grid-cols-2 lg:grid-cols-3">
{data?.data.map((user) => (
<UserCard key={user.id} user={user} />
))}
</div>
{data?.meta && (
<Pagination
page={data.meta.page}
totalPages={data.meta.totalPages}
onPageChange={setPage}
/>
)}
</>
)}
</div>
);
}Error States Robustos
Toda tela que faz fetch DEVE ter estes estados:
- Loading (skeleton)
- Sucesso (dados)
- Erro (mensagem + botao retry)
- Vazio (empty state com acao)
- Timeout (mensagem especifica + retry)
- Offline (detectar navigator.onLine)
- Dados stale (indicador visual quando cache expirou)
Retry pattern no useApi:
const RETRY_CONFIG = {
retries: 3,
retryDelay: (attempt: number) => Math.min(1000 * 2 ** attempt, 10000),
};Quando precisar de imagem (placeholder, avatar default, hero, ilustração)
Não use unsplash/lorem-picsum em prod. Despache skill 17 (image-generator) pra gerar asset alinhado ao projeto:
Tipo: placeholder | avatar-default | hero | illustration
Contexto: [componente onde entra], [paleta do app]
Output path: public/images/ ou assets/
Restrições: [dimensão], [transparência se PNG], [formato preferido]Skill 17 aplica regra default (grok-imagine $0.020 t2i / gemini-25-flash $0.039 edit). Em runtime do app (não em build): usar templates/stack-default/apps/web/src/lib/image.ts se template está sendo consumido.
Evidencia de Conclusao
- interface implementada conforme fluxo esperado
- loading, erro, vazio e auth tratados
- pontos criticos para QA e Motion destacados
Handoff para QA
Entregar:
- App rodando em ambiente de staging
- Lista de features implementadas com rotas
- Componentes interativos documentados (Storybook se houver)
- Variáveis de ambiente documentadas
- Como rodar localmente (README)
Fontes
- Seção "Biblioteca de Componentes para Apps Document-Heavy" curada a partir de extend-hq/ui (MIT, ~1.5k stars) — não é port literal do README, é resumo dos componentes e do modo de instalação relevantes para esta skill. Confirmado por leitura direta do repo (licença, stack, comando de instalação) e da página https://www.extend.ai/ui. O kit já modelava Extend como referência visual em
skills/02-ui-ux-design/data/products.csveui-reasoning.csv, mas não tinha nenhuma menção à biblioteca de componentes React em si — esse era o gap real medido antes de adicionar esta seção. - Seção "Storage Client-Side Reativo" curada a partir de franciscop/brownies (MIT, 2.566 stars, 61 forks, release 4.0.1). API confirmada por leitura direta de
readme.mdepackage.jsondo repo: getter/setter direto emcookies/local/session/db(não.get()/.set()),dbassíncrono,subscribe(obj, key, cb)/unsubscribe()para reagir a mudanças entre abas. Gap medido: grep porlocalStorage|sessionStorage|indexedDB|subscribe()em skill 04 epatterns/não retornava nada — a skill cobria Zustand/React Query para estado de app, mas não tinha padrão para storage local reativo. Tratado como nota de baixa prioridade: o middlewarepersistdo Zustand já cobre a maior parte desse caso quando o projeto já usa Zustand. - Performance em React/Next.js: adaptação de alto nível, em redação própria e sem trechos literais, de Vercel React Best Practices — cascatas de rede, bundle inicial, fronteiras server/client e renderização.
Integração com Pipeline
- Orquestrador (skill 09): Coordena quando esta skill é invocada e define a próxima etapa
- Context Manager (skill 08): Rastreia progresso das tasks dentro desta skill
- Documentador (skill 10): Documenta entregas desta skill durante o desenvolvimento
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

