This is the full developer documentation for SkillDev.pro # Skill+DEV — Skills para Agentes de IA > Um sistema prático de skills para engenheiros que querem usar IA sem abrir mão da qualidade. Instale as que quiser e ative com um slash command. * Skills disponíveis * 22 * Instalações * [](https://skills.sh/fabricioctelles/skills) **Skill+DEV é um catálogo open-source de 22 Agent Skills para agentes de IA**, mantido por [Fabricio Telles](https://ft.ia.br/) sob licença Apache 2.0. Cada skill é uma pasta com um arquivo `SKILL.md` que o agente carrega sob demanda — funciona em Claude Code, Cursor, Kiro, Windsurf e qualquer agente compatível com o formato aberto [Agent Skills](https://agentskills.io). Instalação em um comando: `npx skills add fabricioctelles/skills`. 📦Skills.sh⚙️Manual Instalar todas as skills $`npx skills add fabricioctelles/skills` Atualizar: npx skills update[Skills.sh →](https://skills.sh/fabricioctelles/skills) Clone manual $`git clone https://github.com/fabricioctelles/skills.git ~/.skills` Copie as pastas desejadas para seu projeto 🆕 Nova Skill: Pstack Skill O famoso `poteto-mode` da Lauren Tan como uma única skill autocontida: 23 playbooks, 21 procedures e 21 princípios de engenharia rigorosa — sem plugin, sem Cursor, funciona em qualquer agente. [Ver skill →](/skills/pstack-skill/) 🥷 Jump Skills Ninjas — 500+ Skills em Um **9 Ninjas** para AWS, Azure, Google Cloud, Google AI, Firebase, Mobile, Ads, Analytics e Firecrawl — orquestradores inteligentes que roteiam suas solicitações para a skill certa entre 500+ opções. Carrega apenas \~500 tokens de metadados, executa com expertise. [Conhecer os Ninjas →](/ninja/) *** ## Por que Skills para Agentes de IA? [Seção intitulada “Por que Skills para Agentes de IA?”](#por-que-skills-para-agentes-de-ia) Segundo a [Anthropic](https://claude.com/blog/improving-skill-creator-test-measure-and-refine-agent-skills), skills estruturadas melhoram a qualidade das respostas de agentes em até 40% comparado a prompts ad-hoc. Especialização sob demanda Cada skill encapsula expertise em um domínio específico — de DevOps a marketing, de segurança a UX. Formato aberto Compatível com Kiro, Cursor, Claude Code e qualquer agente que suporte Agent Skills. Instalação em 1 comando Use `npx skills add` ou clone direto do GitHub — zero configuração. Qualidade validada Cada skill passa por avaliação estruturada com métricas objetivas. *** ## Skills em Destaque [Seção intitulada “Skills em Destaque”](#skills-em-destaque) Security Specialist Pipeline de 6 fases, 9 attack classes e validação adversarial. [Ver skill →](/skills/security-specialist/) Loop Architect Orquestre agentes em loops de feedback contínuo. [Ver skill →](/skills/loop-architect/) Humanizar Escreva e reescreva em PT-BR sem os vícios de IA — 13 perfis de voz e trava factual. [Ver skill →](/skills/humanizar/) Pstack Skill O orquestrador de engenharia rigorosa do pstack — 23 playbooks, qualquer agente. [Ver skill →](/skills/pstack-skill/) [Ver todas as skills →](/skills/overview/) *** ## Perguntas Frequentes O que são Skills para agentes de IA? Skills são módulos de conhecimento especializado que ampliam as capacidades de agentes de IA. Cada skill encapsula expertise em um domínio específico — segurança, DevOps, marketing, UX, LGPD — permitindo que o agente atue com profundidade em tarefas complexas sem precisar de prompts extensos. O formato [Agent Skills](https://agentskills.io) é um padrão aberto adotado por milhares de desenvolvedores globalmente. Como instalar skills no meu agente? Use o comando `npx skills add fabricioctelles/skills` para instalar todas as skills do repositório. Você também pode: * Instalar uma skill específica: `npx skills add fabricioctelles/skills -s humanizar` * Clonar manualmente: `git clone https://github.com/fabricioctelles/skills.git` * Copiar apenas a pasta da skill desejada para seu projeto Quais agentes são compatíveis com as skills? As skills são compatíveis com qualquer agente que suporte o formato Agent Skills: * **Kiro** — suporte nativo via KiroCrew * **Cursor** — coloque em `.cursor/skills/` * **Claude Code** — via plugins ou pasta local * **Windsurf** — suporte via extensão * **Outros** — qualquer agente com sistema de prompts personalizados Posso criar minhas próprias skills? Sim! O formato é simples: uma pasta com um arquivo `SKILL.md` contendo as instruções. Consulte a [estrutura de uma skill](/reference/skill-structure/) para detalhes. Você pode publicar no [Skills.sh](https://skills.sh) ou manter privado. As skills funcionam offline? Sim, uma vez instaladas. As skills são arquivos Markdown locais — não dependem de API externa para funcionar. O agente de IA lê as instruções da skill e as aplica durante a conversa. Qual a diferença entre skills e prompts de sistema? Skills são **especializações modulares** que você ativa sob demanda (com `/nome-da-skill`), enquanto prompts de sistema são instruções globais sempre ativas. Skills permitem: * Trocar de contexto sem editar configurações * Combinar múltiplas especialidades em uma sessão * Versionar e compartilhar conhecimento entre projetos As skills são gratuitas? Sim, todas as skills neste repositório são **open-source** sob licença Apache 2.0. Você pode usar, modificar e redistribuir livremente. O código está disponível no [GitHub](https://github.com/fabricioctelles/skills). Como atualizar as skills instaladas? Execute `npx skills update` para atualizar todas as skills para a versão mais recente. Para verificar a versão atual: `npx skills list`. *** ## Referências [Seção intitulada “Referências”](#referências) * [Repositório GitHub — fabricioctelles/skills](https://github.com/fabricioctelles/skills) * [Repositório GitHub — lgpd-app/skills](https://github.com/lgpd-app/skills) — Skills de conformidade LGPD * [Agent Skills — Especificação Oficial](https://agentskills.io/specification.md) * [Anthropic — Improving Skill Creator](https://claude.com/blog/improving-skill-creator-test-measure-and-refine-agent-skills) # Introdução — Skills para Agentes de IA > Entenda o que são skills para agentes de IA, como o Skill+DEV organiza esse conhecimento e por que mais de 5.000 desenvolvedores usam Agent Skills. > **TL;DR:** Skills são módulos de conhecimento que transformam agentes de IA em especialistas sob demanda. O repositório Skill+DEV oferece 9 skills open-source cobrindo negócios, marketing, design, DevOps e mais. ## O que são Skills? [Seção intitulada “O que são Skills?”](#o-que-são-skills) Skills são módulos de conhecimento especializado que ampliam as capacidades de agentes de IA. Cada skill encapsula expertise em um domínio específico — desde frameworks de desenvolvimento até estratégias de marketing — permitindo que o agente atue com profundidade em tarefas complexas. Segundo a [Anthropic](https://claude.com/blog/improving-skill-creator-test-measure-and-refine-agent-skills), skills estruturadas melhoram a qualidade das respostas de agentes em até 40% comparado a prompts ad-hoc. According to [agentskills.io](https://agentskills.io/), o formato é adotado por mais de 5.000 desenvolvedores. > “Agent Skills are a lightweight, open format for extending AI agent capabilities with specialized knowledge and workflows.” — [agentskills.io](https://agentskills.io/what-are-skills.md) ## Por que usar Skills? [Seção intitulada “Por que usar Skills?”](#por-que-usar-skills) 1. **Especialização sob demanda**: Ative apenas o conhecimento necessário para cada tarefa 2. **Consistência**: Garanta que o agente siga padrões e boas práticas documentadas 3. **Reutilização**: Compartilhe conhecimento entre projetos e equipes 4. **Evolução contínua**: Atualize skills independentemente conforme tecnologias evoluem ## O Repositório [Seção intitulada “O Repositório”](#o-repositório) O repositório [github.com/fabricioctelles/skills](https://github.com/fabricioctelles/skills) é a fonte central de skills mantidas pela comunidade. Criado por [Fabricio Telles](https://ft.ia.br/) em abril de 2026, conta com 9 skills revisadas seguindo o padrão Anthropic para Agent Skills. O formato [Agent Skills](https://agentskills.io/) é um padrão aberto adotado por mais de 5.000 desenvolvedores. Cada skill é uma pasta com um arquivo `SKILL.md` contendo metadados e instruções que agentes carregam sob demanda via progressive disclosure. ## Perguntas Frequentes [Seção intitulada “Perguntas Frequentes”](#perguntas-frequentes) ### O que são Skills para agentes de IA? [Seção intitulada “O que são Skills para agentes de IA?”](#o-que-são-skills-para-agentes-de-ia) Skills são módulos de conhecimento especializado que ampliam as capacidades de agentes de IA. Cada skill encapsula expertise em um domínio específico, permitindo que o agente atue com profundidade em tarefas complexas. ### Como instalar skills no meu agente? [Seção intitulada “Como instalar skills no meu agente?”](#como-instalar-skills-no-meu-agente) Use o comando `npx skills add` seguido da URL do repositório GitHub. Também é possível instalar via Agent Skills CLI ou manualmente copiando a pasta da skill para o diretório do agente. ### Quais agentes são compatíveis com as skills? [Seção intitulada “Quais agentes são compatíveis com as skills?”](#quais-agentes-são-compatíveis-com-as-skills) As skills são compatíveis com Kiro, Cursor, Windsurf, Claude Code e qualquer agente que suporte o formato Agent Skills. O formato é universal e aberto. ## Próximos Passos [Seção intitulada “Próximos Passos”](#próximos-passos) * [Como Usar](/guides/how-to-use/) — Aprenda a instalar e configurar skills * [Catálogo de Skills](/skills/overview/) — Explore as skills disponíveis ## References [Seção intitulada “References”](#references) * [Repositório GitHub — fabricioctelles/skills](https://github.com/fabricioctelles/skills) * [Agent Skills — Especificação Oficial](https://agentskills.io/specification.md) * [Anthropic — Improving Skill Creator](https://claude.com/blog/improving-skill-creator-test-measure-and-refine-agent-skills) # Catálogo de Skills para Agentes de IA > Visão geral das 22 skills open-source do Skill+DEV organizadas por categoria — negócios, marketing, escrita, design, DevOps, cloud, qualidade, carreira, automação, segurança, conhecimento e agentes. [](https://skills.sh/fabricioctelles/skills) > **TL;DR:** O repositório conta com 22 skills open-source sob licença Apache 2.0, cobrindo negócios, marketing, escrita, design, DevOps, cloud, qualidade, carreira, automação, segurança, conhecimento e compatibilidade com agentes de IA. Todas revisadas seguindo o padrão Anthropic. ## Skills Disponíveis [Seção intitulada “Skills Disponíveis”](#skills-disponíveis) | # | Skill | Categoria | Descrição | | -- | ----------------------------------------------------------------------- | ------------ | -------------------------------------------------------------------------------------------------------------------- | | 1 | [Startup Idea](/skills/startup-idea/) | Negócios | Análise completa de startups (Paul Graham + Dan Koe + Seth Godin) | | 2 | [Revenue-Centric Design](/skills/revenue-centric-design/) | Negócios | 101 princípios com evidência para converter, reter e monetizar SaaS | | 3 | [GEO Optimization](/skills/geo-optimization/) | Marketing | Otimização para motores generativos (LLMs) | | 4 | [Substack Expert](/skills/substack-expert/) | Marketing | Formatação, SEO e crescimento no Substack | | 5 | [Humanizar](/skills/humanizar/) | Escrita | Escrita e reescrita em PT-BR sem vícios de IA — 13 perfis de voz, guarda de falso positivo e trava factual | | 6 | [Human-AI](/skills/human-ai/) | Escrita | Reescrita de texto EN com 43 padrões, scoring iterativo e `measure.py` — irmã da Humanizar | | 7 | [Pier Cloud API](/skills/pier-cloud/) | Cloud/FinOps | Consumo da API Pier Cloud (Lighthouse) | | 8 | [Coolify Operator](/skills/coolify-operator/) | DevOps | Operador master da plataforma Coolify | | 9 | [Astro Sites Manager](/skills/astro-sites-manager/) | DevOps | Construção, migração e manutenção de projetos Astro v7 — deploy em 8+ plataformas | | 10 | [Security Specialist](/skills/security-specialist/) | Segurança | Auditoria de segurança com pipeline de 6 fases, 9 attack classes e validação adversarial | | 11 | [Ultimate Design System Master](/skills/ultimate-design-system-master/) | Design | Design systems de nível Apple/Vercel/Figma | | 12 | [DESIGN.md Validator](/skills/design-md-validator/) | Design | Validação de DESIGN.md contra spec Google — lint, diff, export, WCAG | | 13 | [Skill Evaluation](/skills/skill-evaluation/) | Qualidade | Avalia skills contra 12 critérios (Anthropic + agentskills.io) — scorecard + grade | | 14 | [Slop Eval](/skills/slop-eval/) | Qualidade | Avalia design UI/web contra lei anti-slop — 8 eixos, Slop Index 0–100, gate para CI | | 15 | [Agent Plugin Eval](/skills/agent-plugin-eval/) | Qualidade | Audita Agent Plugins portáveis — 18 critérios, gate PASS/PARTIAL/FAIL, auditoria estática | | 16 | [Agent Ready — Cloudflare](/skills/agent-ready-cloudflare/) | Agentes IA | Auditoria de sites para compatibilidade com agentes | | 17 | [Auth.md](/skills/auth-md/) | Agentes IA | Protocolo aberto para agentes AI se registrarem em serviços | | 18 | [Pstack Skill](/skills/pstack-skill/) | Agentes IA | ⭐ Orquestrador de engenharia rigorosa portado do pstack da Lauren Tan — 23 playbooks, 21 procedures, qualquer agente | | 19 | [OKF — Open Knowledge Format](/skills/okf-open-knowledge-format/) | Conhecimento | Cria, valida e enriquece bundles OKF — o pattern “LLM Wiki” formalizado como spec | | 20 | [Ralph Loop for Kiro Specs](/skills/ralph-loop-kiro-specs/) | Automação | Runner iterativo auto-corretivo para specs do Kiro | | 21 | [Loop Architect](/skills/loop-architect/) | Automação | Coach de design de agent loops com review gates e artefatos portáveis | | 22 | [Resume ATS Beater](/skills/resume-ats-beater/) | Carreira | Reescrita de currículos para ATS | ## Skills Aposentadas [Seção intitulada “Skills Aposentadas”](#skills-aposentadas) Saíram do repositório porque o projeto original passou a oferecer algo mais completo. As páginas continuam no ar apontando para a fonte oficial. | Skill | Substituída por | | --------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ | | [Front-End Checklist](/skills/front-end-checklist/) | [thedaviddias/Front-End-Checklist](https://github.com/thedaviddias/Front-End-Checklist/tree/main/skills) — 385 skills, uma por regra | | [Website Spec](/skills/website-spec/) | Skill oficial do [specification.website](https://specification.website) — 140+ tópicos, atualização live via MCP | | [LGPD Check](/skills/lgpd-check/) | [lgpd-app/skills](https://github.com/lgpd-app/skills) | | [LGPD.md](/skills/lgpd-md/) | [lgpd-app/skills](https://github.com/lgpd-app/skills) | ## Instalação Rápida [Seção intitulada “Instalação Rápida”](#instalação-rápida) ```bash # Todas as skills npx skills add https://github.com/fabricioctelles/skills # Skill específica npx skills add https://github.com/fabricioctelles/skills -s ``` ## Estatísticas do Repositório [Seção intitulada “Estatísticas do Repositório”](#estatísticas-do-repositório) * **22 skills** disponíveis e documentadas * **100%** revisadas seguindo o [padrão Anthropic para Agent Skills](https://claude.com/blog/improving-skill-creator-test-measure-and-refine-agent-skills) * **Licença Apache 2.0** — uso livre em qualquer projeto * **5+ agentes** compatíveis: Kiro, Cursor, Windsurf, Claude Code e outros * Criado por [Fabricio Telles](https://ft.ia.br/) — atualizado em setembro de 2026 ## Perguntas Frequentes [Seção intitulada “Perguntas Frequentes”](#perguntas-frequentes) ### Quantas skills estão disponíveis? [Seção intitulada “Quantas skills estão disponíveis?”](#quantas-skills-estão-disponíveis) Atualmente o repositório conta com 22 skills cobrindo áreas como negócios, marketing, escrita, design, DevOps, cloud, qualidade, carreira, automação, segurança, conhecimento e compatibilidade com agentes de IA. ### As skills são gratuitas? [Seção intitulada “As skills são gratuitas?”](#as-skills-são-gratuitas) Sim, todas as skills são open-source sob licença Apache 2.0 e podem ser usadas livremente em qualquer projeto. ### Como contribuir com uma nova skill? [Seção intitulada “Como contribuir com uma nova skill?”](#como-contribuir-com-uma-nova-skill) Consulte a [referência de estrutura de skills](/reference/skill-structure/) e abra um pull request no [repositório GitHub](https://github.com/fabricioctelles/skills). ## Contribuindo [Seção intitulada “Contribuindo”](#contribuindo) Para adicionar uma nova skill ao catálogo, siga a [estrutura padrão](/reference/skill-structure/) e abra um pull request no [repositório GitHub](https://github.com/fabricioctelles/skills). ## References [Seção intitulada “References”](#references) * [Repositório GitHub — fabricioctelles/skills](https://github.com/fabricioctelles/skills) * [Agent Skills — Especificação Oficial](https://agentskills.io/specification.md) * [Anthropic — Improving Skill Creator](https://claude.com/blog/improving-skill-creator-test-measure-and-refine-agent-skills) # AWS Ninja — 217+ Skills AWS para Agentes de IA > Uma skill para orquestrar todas. Acesse 217+ skills AWS oficiais sem desperdiçar sua janela de contexto. * Skills AWS * 217+ * Agentes Suportados * 36+ * Repositórios Oficiais * 6 * Licença * MIT *** ## O Problema [Seção intitulada “O Problema”](#o-problema) Você tem acesso a **217+ skills AWS oficiais** distribuídas em 6 repositórios diferentes. Mas carregar todas no contexto do seu agente de IA: * Consome toda a janela de contexto antes de você começar * Deixa as respostas mais lentas * Skills irrelevantes interferem nas respostas ## A Solução: Jump Skill [Seção intitulada “A Solução: Jump Skill”](#a-solução-jump-skill) **AWS Ninja** é uma **jump skill** — um roteador inteligente que: 1. **Analisa** sua tarefa AWS (EKS, Lambda, segurança, custos…) 2. **Identifica** as skills mais relevantes do catálogo de 217+ 3. **Carrega** apenas as instruções necessárias sob demanda 4. **Executa** com conhecimento de Solutions Architect **Resultado:** Seu agente vira expert AWS sem desperdiçar contexto. *** ## Como Funciona [Seção intitulada “Como Funciona”](#como-funciona) ```plaintext ┌─────────────────────────────────────────────────────────────────┐ │ /aws-ninja Design um cluster EKS para fintech com PCI-DSS │ └─────────────────────────────────────────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────────────────────────┐ │ AWS NINJA │ │ (Jump Skill Router) │ │ │ │ ✓ Analisa contexto da tarefa │ │ ✓ Busca no catálogo de 217 skills │ │ ✓ Identifica: eks-design + eks-security │ │ ✓ Carrega SKILL.md com procedimentos completos │ └─────────────────────────────────────────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────────────────────────┐ │ EXECUÇÃO ESPECIALIZADA │ │ │ │ Fonte: sample-apex-skills/skills/eks-design/ │ │ Conhecimento: AWS EKS Best Practices, CIS Benchmarks │ │ Output: Diagramas de arquitetura, Terraform, ADRs │ └─────────────────────────────────────────────────────────────────┘ ``` *** ## Instalação * Linux/macOS 1. Clone o repositório ```bash git clone https://github.com/fabricioctelles/aws-ninja.git cd aws-ninja ``` 2. Sincronize os repositórios AWS ```bash ./sync-repos.sh ``` 3. Instale nos seus agentes ```bash ./install-aws-ninja.sh --global ``` * Windows (PowerShell) 1. Clone o repositório ```powershell git clone https://github.com/fabricioctelles/aws-ninja.git cd aws-ninja ``` 2. Sincronize os repositórios AWS ```powershell .\sync-repos.ps1 ``` 3. Instale nos seus agentes ```powershell .\install-aws-ninja.ps1 -Global ``` Instalação Seletiva Instale apenas em agentes específicos: * **Bash:** `./install-aws-ninja.sh claude-code cursor kiro-cli` * **PowerShell:** `.\install-aws-ninja.ps1 -Agents claude-code,cursor,kiro-cli` *** ## Exemplos de Uso [Seção intitulada “Exemplos de Uso”](#exemplos-de-uso) Invoque com `/aws-ninja` seguido da sua tarefa: | Comando | Roteado Para | | ---------------------------------------------------------------- | --------------------------------------- | | `/aws-ninja Design um cluster EKS para fintech com PCI-DSS` | `eks-design` + `eks-security` | | `/aws-ninja Me ajude a escolher entre DynamoDB e Aurora` | `aws-database` → skill específica | | `/aws-ninja Escaneie este Terraform para problemas de segurança` | `scanning-with-aws-security-agent` | | `/aws-ninja Reduza custos no nosso cluster EKS` | `eks-cost-intelligence` | | `/aws-ninja Por que minha Lambda está dando timeout?` | `debugging-lambda-timeouts` | | `/aws-ninja Execute uma revisão Well-Architected` | `aws-well-architected-framework-review` | | `/aws-ninja Configure uma VPC de produção com subnets privadas` | `creating-production-vpc-multi-az` | *** ## Catálogo de Skills [Seção intitulada “Catálogo de Skills”](#catálogo-de-skills) **217+ skills** organizadas por domínio AWS. Todas de **repositórios oficiais da AWS**. Compute & Containers **23 skills** — EKS, ECS, Lambda, EC2, Fargate, Graviton `eks-design` `eks-build` `eks-security` `eks-upgrade-check` `ecs-architect` `aws-serverless` Databases **12 skills** — DynamoDB, Aurora, RDS, ElastiCache, Neptune, DocumentDB `amazon-dynamodb` `amazon-aurora-mysql` `amazon-aurora-postgresql` `amazon-rds` `amazon-elasticache` Security & Identity **20+ skills** — IAM, GuardDuty, Security Hub, WAF, KMS, Secrets Manager `aws-iam` `aws-security-services` `aws-security-hub-reactor` `scanning-with-aws-security-agent` Infrastructure **15+ skills** — VPC, CloudFormation, CDK, Terraform, networking `creating-production-vpc-multi-az` `cdk-*` `aws-networking` `aws-cloudformation` DevOps & Operations **18+ skills** — CI/CD, observabilidade, incidents, troubleshooting `building-ci-cd-pipelines` `investigating-aws-incidents` `amazon-cloudwatch` `aws-x-ray` Well-Architected **5 skills** — Reviews completos dos 6 pilares `aws-well-architected-framework-review` `security-pillar` `cost-optimization-pillar` [Ver catálogo completo →](https://github.com/fabricioctelles/aws-ninja/blob/main/aws-ninja/references/skill-catalog.md) *** ## Repositórios Fonte [Seção intitulada “Repositórios Fonte”](#repositórios-fonte) Skills extraídas de repositórios **oficiais da AWS**: | Organização | Repositório | Skills | Foco | | --------------- | ------------------------------------------------------------------------------------------------------------------------- | ------ | ----------------------------------------------- | | **aws** | [agent-toolkit-for-aws](https://github.com/aws/agent-toolkit-for-aws) | 100+ | Serviços core, databases, serverless, segurança | | **aws** | [tools-for-devops-agent](https://github.com/aws/tools-for-devops-agent) | 15 | Operações, incidents, reviews RDS/EKS | | **aws-samples** | [sample-apex-skills](https://github.com/aws-samples/sample-apex-skills) | 25+ | EKS, ECS, platform engineering | | **aws-samples** | [sample-agent-skills-for-builders](https://github.com/aws-samples/sample-agent-skills-for-builders) | 13 | CDK, testes, estimativa de custos | | **aws-samples** | [sample-well-architected-skills-and-steering](https://github.com/aws-samples/sample-well-architected-skills-and-steering) | 5 | Revisões Well-Architected | | **aws-samples** | [sample-corgiro-aws-ops-skills](https://github.com/aws-samples/sample-corgiro-aws-ops-skills) | 1 | Operações multi-account | *** ## Agentes Suportados [Seção intitulada “Agentes Suportados”](#agentes-suportados) O instalador detecta automaticamente e instala nos agentes disponíveis: Claude Code Anthropic Kiro Amazon Cursor Cursor GitHub Copilot GitHub Windsurf Codeium Codex CLI OpenAI **E mais 30+ agentes:** Gemini CLI, Cline, Roo, Continue, Goose, OpenHands, Tabnine, Augment, Amp, e outros. *** ## Por que Jump Skills? [Seção intitulada “Por que Jump Skills?”](#por-que-jump-skills) | Abordagem Tradicional | Abordagem Jump Skill | | ------------------------------------ | --------------------------------------- | | Carrega todas 217 skills no contexto | Carrega apenas metadados (\~500 tokens) | | Consome toda janela de contexto | Uso mínimo de contexto | | Respostas mais lentas | Roteamento rápido | | Skills irrelevantes interferem | Sempre usa a skill mais específica | *** ## Perguntas Frequentes Por que não instalar todas as skills diretamente? A Jump Skill evita que sua janela de contexto seja gasta desnecessariamente — ela carrega só as skills necessárias para cada tarefa. Com 217 skills, carregar todas consumiria todo o contexto antes de você começar a trabalhar. As skills são oficiais da AWS? Sim! Todas as 217+ skills vêm de repositórios oficiais da AWS no GitHub: `aws/agent-toolkit-for-aws`, `aws-samples/sample-apex-skills`, e outros repositórios mantidos pela AWS. Funciona offline? Sim, após a instalação. Os repositórios são clonados localmente e as skills são arquivos Markdown — não dependem de API externa para funcionar. Como atualizar as skills? Execute `./sync-repos.sh` (Linux/macOS) ou `.\sync-repos.ps1` (Windows) para atualizar todos os repositórios AWS para a versão mais recente. Posso usar com skills customizadas? Sim! O AWS Ninja roteia para skills AWS oficiais, mas você pode ter outras skills instaladas em paralelo. Elas não interferem. Qual a licença? MIT — você pode usar, modificar e redistribuir livremente. O código está disponível no [GitHub](https://github.com/fabricioctelles/aws-ninja). *** ## Contribuindo [Seção intitulada “Contribuindo”](#contribuindo) Contribuições são bem-vindas! Veja o [guia de contribuição](https://github.com/fabricioctelles/aws-ninja/blob/main/CONTRIBUTING.md). *** [](https://ft.ia.br)\ Built by ft.ia.br # Como Instalar e Usar Skills para Agentes de IA > Guia prático para instalar, configurar e ativar skills com Kiro, Cursor, Claude Code e outros agentes compatíveis com o formato Agent Skills. > **TL;DR:** Instale skills com `npx skills add`, copie para a pasta do seu agente e ative automaticamente por palavras-chave. Compatível com Kiro, Cursor, Claude Code e qualquer agente que suporte o formato Agent Skills. ## Instalação [Seção intitulada “Instalação”](#instalação) ### Via Skills.sh (recomendado) [Seção intitulada “Via Skills.sh (recomendado)”](#via-skillssh-recomendado) ```bash npx skills add https://github.com/fabricioctelles/skills ``` Ou instale uma skill específica: ```bash npx skills add https://github.com/fabricioctelles/skills -s geo-optimization ``` ### Via Agent Skills CLI [Seção intitulada “Via Agent Skills CLI”](#via-agent-skills-cli) ```bash npm install -g agent-skills-cli skills add https://github.com/fabricioctelles/skills ``` ### Instalação Manual [Seção intitulada “Instalação Manual”](#instalação-manual) Clone o repositório e copie a skill desejada: ```bash git clone https://github.com/fabricioctelles/skills.git # Cursor cp -r skills/geo-optimization .cursor/skills/ # Claude Code cp -r skills/geo-optimization .claude/skills/ # Kiro cp -r skills/geo-optimization .kiro/skills/ ``` O formato [Agent Skills](https://agentskills.io/) é universal e funciona com qualquer agente compatível. Consulte a [especificação oficial](https://agentskills.io/specification.md) para detalhes. ## Estrutura de uma Skill [Seção intitulada “Estrutura de uma Skill”](#estrutura-de-uma-skill) Cada skill segue a estrutura padrão com progressive disclosure — o agente carrega apenas o que precisa: ```mermaid graph TD A[skill-name/] --> B[SKILL.md] A --> C[references/] A --> D[evals/] B --> E[Metadados + Instruções] C --> F[Docs de referência] D --> G[Cenários de teste] ``` ## Ativação [Seção intitulada “Ativação”](#ativação) Skills são ativadas automaticamente quando o agente detecta palavras-chave relacionadas na mensagem do usuário. Você também pode ativar manualmente referenciando o nome da skill. ## Configuração [Seção intitulada “Configuração”](#configuração) As skills podem ser configuradas como: 1. **Globais** — Sempre disponíveis em todas as interações 2. **Condicionais** — Ativadas quando arquivos específicos são lidos 3. **Manuais** — Ativadas explicitamente pelo usuário ## Perguntas Frequentes [Seção intitulada “Perguntas Frequentes”](#perguntas-frequentes) ### Qual o comando para instalar todas as skills? [Seção intitulada “Qual o comando para instalar todas as skills?”](#qual-o-comando-para-instalar-todas-as-skills) Execute `npx skills add https://github.com/fabricioctelles/skills` para instalar todas as 9 skills de uma vez no seu ambiente. ### Posso instalar apenas uma skill específica? [Seção intitulada “Posso instalar apenas uma skill específica?”](#posso-instalar-apenas-uma-skill-específica) Sim, use o flag `-s` seguido do nome: `npx skills add https://github.com/fabricioctelles/skills -s nome-da-skill`. ### As skills funcionam com Cursor e Kiro? [Seção intitulada “As skills funcionam com Cursor e Kiro?”](#as-skills-funcionam-com-cursor-e-kiro) Sim, o formato Agent Skills é universal. Copie a pasta da skill para `.cursor/skills/`, `.kiro/skills/` ou `.claude/skills/` conforme seu agente. ## Próximos Passos [Seção intitulada “Próximos Passos”](#próximos-passos) * [Catálogo de Skills](/skills/overview/) — Explore as skills disponíveis * [Estrutura de Skills](/reference/skill-structure/) — Referência técnica completa ## References [Seção intitulada “References”](#references) * [Skills.sh — Instalador de Skills](https://skills.sh/docs) * [Agent Skills CLI](https://www.agentskills.in/docs) * [Especificação Agent Skills](https://agentskills.io/specification.md) * [Repositório GitHub](https://github.com/fabricioctelles/skills) # Jump Skills Ninjas — Orquestradores Inteligentes para Agentes de IA > Uma skill para orquestrar todas. Acesse 540+ skills de AWS, Azure, Google Cloud, Firebase, Datadog e Firecrawl sem desperdiçar sua janela de contexto. * Ninjas * 10 * Skills Totais * 540+ * Agentes Suportados * 10+ * Licença * MIT *** ## 🤔 O Que São Ninjas? [Seção intitulada “🤔 O Que São Ninjas?”](#-o-que-são-ninjas) **Ninjas** são **meta-skills** inteligentes — orquestradores mestres que roteiam suas solicitações para a skill especializada mais apropriada de uma biblioteca curada. Em vez de procurar manualmente entre centenas de skills individuais, você simplesmente descreve sua tarefa e o Ninja: 🎯 Identifica Analisa sua tarefa e encontra as skills mais relevantes 📖 Carrega Carrega as instruções completas sob demanda ⚡ Executa Executa com conhecimento de nível expert Pense nos Ninjas como **despachantes especialistas** — eles entendem todo o panorama de capacidades disponíveis e sempre te direcionam ao especialista certo. *** ## 🧠 O Problema que Ninjas Resolvem [Seção intitulada “🧠 O Problema que Ninjas Resolvem”](#-o-problema-que-ninjas-resolvem) ### Sem Ninja (Abordagem Tradicional) [Seção intitulada “Sem Ninja (Abordagem Tradicional)”](#sem-ninja-abordagem-tradicional) ```plaintext ┌─────────────────────────────────────────────────────────────────┐ │ Carregar todas as 500+ skills no contexto │ │ │ │ ❌ Consome toda a janela de contexto │ │ ❌ Respostas mais lentas │ │ ❌ Skills irrelevantes interferem │ │ ❌ Confusão sobre qual skill usar │ └─────────────────────────────────────────────────────────────────┘ ``` ### Com Ninja (Jump Skill) [Seção intitulada “Com Ninja (Jump Skill)”](#com-ninja-jump-skill) ```plaintext ┌─────────────────────────────────────────────────────────────────┐ │ "Configure um cluster EKS com Karpenter para autoscaling" │ └─────────────────────────────────────────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────────────────────────┐ │ 🥷 AWS NINJA │ │ Analisa intent & contexto │ │ │ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │ │ eks-design │ │eks-karpenter│ │eks-security │ │ │ │ skill │ ── │ skill │ ── │ skill │ │ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │ ▲ ▲ │ │ └────── SELECIONADAS ──┘ │ └─────────────────────────────────────────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────────────────────────────┐ │ EXECUÇÃO EXPERT │ │ Conhecimento completo carregado & tarefa executada │ └─────────────────────────────────────────────────────────────────┘ ``` **Resultado:** * ✅ Apenas \~500 tokens de metadata carregados inicialmente * ✅ Skills completas carregadas sob demanda * ✅ 100x menos uso de contexto * ✅ Sempre usa a skill mais específica *** ## 🥷 Ninjas Disponíveis [Seção intitulada “🥷 Ninjas Disponíveis”](#-ninjas-disponíveis) ### ☁️ Cloud Providers [Seção intitulada “☁️ Cloud Providers”](#️-cloud-providers) ☁️ AWS Ninja **230+ skills** de 10 repositórios oficiais AWS EKS, Lambda, DynamoDB, CDK, Security, Well-Architected, Bedrock, e muito mais. [Ver AWS Ninja →](/aws-ninja) 🔷 Azure Ninja **40 skills** da Microsoft + comunidade AKS, App Service, Entra ID, Foundry, DevOps, Cost Management, Bicep. *Workflow: prepare → validate → deploy* 🌐 Google Cloud Ninja **85+ skills** de repositórios oficiais Google GKE, Cloud Run, BigQuery, Spanner, IAM, Storage, Well-Architected Framework. ### 🤖 Google AI & ML [Seção intitulada “🤖 Google AI & ML”](#-google-ai--ml) 🧠 Google AI Ninja **25+ skills** para IA Generativa Gemini API, Agent Platform, Genkit, RAG, Eval, ADK. 📊 Google Analytics Ninja **3+ skills** para Analytics Admin API, Data API, Reports, Metrics, Dimensions. 📢 Google Ads Ninja **15+ skills** para publicidade Ads API, Mobile Ads SDK, IMA SDK, Data Manager. ### 📱 Mobile & Firebase [Seção intitulada “📱 Mobile & Firebase”](#-mobile--firebase) 📱 Google Mobile Ninja **35+ skills** para desenvolvimento mobile Android, Flutter, Dart, Jetpack Compose, Navigation 3, CameraX. 🔥 Google Firebase Ninja **18+ skills** para backend-as-a-service Firestore, Auth, Hosting, Functions, Storage, Remote Config. ### 📊 Observabilidade [Seção intitulada “📊 Observabilidade”](#-observabilidade) 🐕 Datadog Ninja **57 skills** para observabilidade e monitoramento APM & Tracing, Logs, Monitors, Live Debugging, CI & Test Optimization, Audit Trail, Browser SDK & RUM, LLM Ops. ### 🕷️ Web Scraping [Seção intitulada “🕷️ Web Scraping”](#️-web-scraping) 🔥 Firecrawl Ninja **33 skills** para web scraping e research Scrape, crawl, batch operations, deep research, LLM-ready extraction. *** ## 📊 Resumo dos Ninjas [Seção intitulada “📊 Resumo dos Ninjas”](#-resumo-dos-ninjas) | Ninja | Skills | Categoria | Fonte | | -------------------------- | ------ | --------------- | ------------------------------------------------------------- | | **AWS Ninja** | 230+ | Cloud | `aws/`, `aws-samples/` | | **Azure Ninja** | 40 | Cloud | `microsoft/azure-skills` | | **Google Cloud Ninja** | 85+ | Cloud | `google/skills` | | **Google AI Ninja** | 25+ | AI/ML | `google/skills`, `google/agents-cli` | | **Google Ads Ninja** | 15+ | Ads | `google/skills` | | **Google Mobile Ninja** | 35+ | Mobile | `android/skills`, `flutter/agent-plugins`, `dart-lang/skills` | | **Google Firebase Ninja** | 18+ | BaaS | `firebase/agent-skills` | | **Google Analytics Ninja** | 3+ | Analytics | `google/skills` | | **Datadog Ninja** | 57 | Observabilidade | `DataDog/pup`, `datadog-labs/agent-skills` | | **Firecrawl Ninja** | 33 | Scraping | `firecrawl/skills` | *** ## 📊 Comparativo: Tradicional vs Jump Skill [Seção intitulada “📊 Comparativo: Tradicional vs Jump Skill”](#-comparativo-tradicional-vs-jump-skill) | Aspecto | Abordagem Tradicional | Jump Skill Ninja | | -------------------- | -------------------------------- | ------------------------------- | | **Contexto inicial** | \~100,000+ tokens | \~500 tokens | | **Velocidade** | Lenta (muito a processar) | Rápida (routing inteligente) | | **Precisão** | Skills irrelevantes interferem | Sempre a skill mais específica | | **Manutenção** | Atualizar cada skill manualmente | `./sync-repos.sh` atualiza tudo | | **Multi-cloud** | Configs separadas | Um sistema unificado | *** ## 📦 Instalação Importante Jump Skills **não pode** ser instalado via `npx skills`. É um meta-repositório que orquestra skills de múltiplos repos externos. ### 🤖 Peça ao Seu Agente [Seção intitulada “🤖 Peça ao Seu Agente”](#-peça-ao-seu-agente) Copie e cole este prompt no seu agente de IA: ```plaintext Clone https://github.com/fabricioctelles/jump-skills, depois execute ./sync-repos.sh para clonar todos os repositórios de skills, e ./install-ninjas.sh para instalar os Ninjas. ``` ### Instalação Manual [Seção intitulada “Instalação Manual”](#instalação-manual) * Linux/macOS ```bash # 1. Clone o repositório git clone https://github.com/fabricioctelles/jump-skills.git cd jump-skills # 2. Sincronize os repositórios fonte (~20 repos, ~800MB) ./sync-repos.sh # 3. Instale os Ninjas nos seus agentes ./install-ninjas.sh ``` * Windows ```powershell # 1. Clone o repositório git clone https://github.com/fabricioctelles/jump-skills.git $HOME\GIT\jump-skills cd $HOME\GIT\jump-skills # 2. Sincronize e instale (via Git Bash ou WSL) bash ./sync-repos.sh bash ./install-ninjas.sh ``` ### Agentes Suportados [Seção intitulada “Agentes Suportados”](#agentes-suportados) | Agente | Path | | --------------- | --------------------------- | | Claude Code | `~/.claude/skills/` | | Kiro CLI | `~/.kiro/skills/` | | Cursor | `~/.cursor/skills/` | | Codex | `~/.codex/skills/` | | OpenCode | `~/.opencode/skills/` | | VS Code Copilot | `~/.github/copilot/skills/` | | E mais… | Auto-detectados | *** ## ❓ FAQ [Seção intitulada “❓ FAQ”](#-faq) ## Perguntas Frequentes Por que não instalar todas as skills diretamente? Eficiência de janela de contexto. Se você instalasse todas as 500+ skills diretamente, seu agente de IA carregaria todas na inicialização, consumindo toda a janela de contexto antes mesmo de você fazer uma pergunta. Ninjas são Jump Skills — carregam apenas \~500 tokens de metadata, depois carregam instruções completas sob demanda. Quais agentes de IA são suportados? 10+ agentes incluindo Claude Code, Kiro CLI, Cursor, Codex, OpenCode, VS Code Copilot e mais. O instalador auto-detecta agentes disponíveis no seu sistema. De onde vêm as skills? Todas as skills vêm de repositórios oficiais: AWS de aws/ e aws-samples/, Azure de microsoft/azure-skills, Google de google/skills, Android de android/skills, Flutter de flutter/agent-plugins, Firebase de firebase/agent-skills, Datadog de DataDog/pup e datadog-labs/agent-skills, e Firecrawl de firecrawl/skills. Com que frequência devo atualizar? Execute ./sync-repos.sh semanalmente ou antes de projetos importantes para obter as melhores práticas mais recentes e novas skills. Posso adicionar Ninjas customizados? Sim! Veja CONTRIBUTING.md no repositório para o guia completo de como adicionar novos Ninjas para outras plataformas. Funciona offline? Sim, após o ./sync-repos.sh inicial. Todas as skills são clonadas localmente no diretório repos/. *** ## 🔗 Links [Seção intitulada “🔗 Links”](#-links) GitHub [fabricioctelles/jump-skills](https://github.com/fabricioctelles/jump-skills) AWS Ninja [Página dedicada →](/aws-ninja) *** Feito com 🥷 por [Fabricio Telles](https://ft.ia.br) # Estrutura de Skills > Referência técnica da estrutura padrão de uma skill, incluindo campos obrigatórios e opcionais. ## Estrutura de Diretório [Seção intitulada “Estrutura de Diretório”](#estrutura-de-diretório) ```plaintext skill-name/ ├── skill.md # Definição principal (obrigatório) ├── references/ # Documentação de referência detalhada │ ├── api.md │ └── patterns.md ├── rules/ # Regras contextuais │ └── coding-style.md └── examples/ # Exemplos práticos (opcional) └── basic-usage.md ``` ## Arquivo Principal (skill.md) [Seção intitulada “Arquivo Principal (skill.md)”](#arquivo-principal-skillmd) O arquivo `skill.md` é o ponto de entrada da skill e deve conter: ### Seções Obrigatórias [Seção intitulada “Seções Obrigatórias”](#seções-obrigatórias) | Seção | Descrição | | ------------------- | ----------------------------------------- | | **Role Definition** | Descrição do papel e expertise da skill | | **When to Use** | Condições de ativação e palavras-chave | | **Critical Rules** | Regras que DEVEM e NÃO DEVEM ser seguidas | | **Technologies** | Stack tecnológica coberta | ### Seções Recomendadas [Seção intitulada “Seções Recomendadas”](#seções-recomendadas) | Seção | Descrição | | --------------------------- | ----------------------------------------- | | **Core Workflow** | Fluxo de trabalho principal | | **Decision Frameworks** | Árvores de decisão para escolhas técnicas | | **Reference Documentation** | Links para referências detalhadas | | **Quick Reference** | Snippets e padrões de uso rápido | ## Convenções de Nomenclatura [Seção intitulada “Convenções de Nomenclatura”](#convenções-de-nomenclatura) * Use `kebab-case` para nomes de skills e arquivos * Prefixe regras com o contexto: `astro-components.rule.md` * Use extensão `.md` para todos os arquivos de documentação ## Metadados [Seção intitulada “Metadados”](#metadados) Skills podem incluir metadados no frontmatter: ```yaml --- name: astro-framework version: 1.0.0 keywords: [astro, islands, static, SSR] --- ``` # Skills nas Plataformas Web > Guia completo de como instalar, criar e usar skills diretamente no browser em cada agente IA — ChatGPT, Claude, Manus, Gemini e Perplexity. Skills não são mais exclusividade de agentes CLI. Em Julho de 2026, as principais plataformas de IA oferecem gestão de skills diretamente no browser — criar, instalar, compartilhar e usar workflows reutilizáveis sem sair do chat. ## Visão Geral [Seção intitulada “Visão Geral”](#visão-geral) | Plataforma | Skills no browser | URL de acesso | Formato | | ------------------- | ----------------- | --------------------------------------- | ------------------------ | | **ChatGPT** | ✅ | `chatgpt.com/skills` | SKILL.md (open standard) | | **Claude** | ✅ | `claude.ai/customize/skills` | SKILL.md (ZIP upload) | | **Manus** | ✅ | `manus.im/app#settings/skills` | SKILL.md (open standard) | | **Gemini (Chrome)** | ✅ | Sidebar `/` ou `chrome://skills/browse` | Prompts salvos | | **Perplexity** | ⚠️ Parcial | Computer + Spaces | Proprietário | | **Copilot** | ❌ | — | — | *** ## ChatGPT [Seção intitulada “ChatGPT”](#chatgpt) **URL:** [chatgpt.com/skills](https://chatgpt.com/skills) **Planos:** Business, Enterprise, Healthcare, Edu (skills pessoais). Pro/Plus para uso com Codex. ### Como criar [Seção intitulada “Como criar”](#como-criar) 1. **Via chat** — Peça: “Build me a skill que faz X”. O ChatGPT gera o SKILL.md e oferece botão **Install**. 2. **Via editor** — Sidebar → Plugins → Skills → Create → **Create with editor** 3. **Via upload** — Skills → Create → **Upload from your computer** (ZIP com SKILL.md + resources) ### Como usar [Seção intitulada “Como usar”](#como-usar) * **Automático**: Após instalada, o ChatGPT usa a skill quando detecta relevância * **Explícito**: Mencione com `@nome-da-skill` no chat * **Codex**: No Codex, acesse via Plugins → Skills no canto superior esquerdo ### Como compartilhar [Seção intitulada “Como compartilhar”](#como-compartilhar) * Botão **Share** na skill → link direto ou publicar no workspace * Enterprise admins podem instalar skills para toda a organização * Skills seguem o **Agent Skills open standard** (agentskills.io) — portáveis entre plataformas ### Skill nativa [Seção intitulada “Skill nativa”](#skill-nativa) Vem com `skill-creator` pré-instalada que ajuda a gerar outras skills via conversa. *** ## Claude [Seção intitulada “Claude”](#claude) **URL:** [claude.ai/customize/skills](https://claude.ai/customize/skills) **Planos:** Free, Pro, Max, Team, Enterprise (todos). ### Pré-requisitos [Seção intitulada “Pré-requisitos”](#pré-requisitos) 1. Ativar **Code execution and file creation** em Settings → Capabilities 2. Para Team/Enterprise: Owner deve habilitar em Organization settings → Skills ### Como criar [Seção intitulada “Como criar”](#como-criar-1) 1. **Upload ZIP** — Customize → Skills → “+” → “Create skill” → **Upload a skill** 2. O ZIP deve conter a pasta da skill com `SKILL.md` + scripts/resources 3. Não é possível criar skills via chat (diferente do ChatGPT) ### Como usar [Seção intitulada “Como usar”](#como-usar-1) * **Automático**: Claude usa skills quando detecta relevância na conversa * **Explícito**: Peça “Use my skill X para fazer Y” ou digite `/nome-skill` * **Microsoft 365**: Skills funcionam nos add-ins Excel, Word, PowerPoint e Outlook ### Skills built-in (Anthropic) [Seção intitulada “Skills built-in (Anthropic)”](#skills-built-in-anthropic) Já inclusas sem precisar instalar: * Enhanced Excel spreadsheet creation * Professional Word document creation * PowerPoint presentation generation * PDF creation and processing ### Como compartilhar [Seção intitulada “Como compartilhar”](#como-compartilhar-1) * Botão **Share** → pessoas específicas ou organização inteira * Team/Enterprise: Directory com Skills + Connectors + Plugins em um só lugar * Owners podem provisionar skills para todos os membros automaticamente ### Segurança [Seção intitulada “Segurança”](#segurança) * Skills passam por scan antes de ficarem disponíveis * Algumas podem ser marcadas **Needs Review** ou **Blocked** * Sempre revise skills de fontes externas antes de habilitar *** ## Manus (Meta) [Seção intitulada “Manus (Meta)”](#manus-meta) **URL:** [manus.im/app#settings/skills](https://manus.im/app#settings/skills) **Planos:** Free e Team. ### Como criar [Seção intitulada “Como criar”](#como-criar-2) 1. **Via conversa** — Complete uma task → diga “Package this workflow as a Skill” → Manus gera SKILL.md automaticamente 2. **Import externo** — One-click import de URL ou upload de SKILL.md ### Como usar [Seção intitulada “Como usar”](#como-usar-2) * **Slash command**: Digite `/NOME_DA_SKILL` no chat para triggering explícito * **Automático**: Manus reconhece skills relevantes pelo metadata ### Diferencial: Execução real em sandbox [Seção intitulada “Diferencial: Execução real em sandbox”](#diferencial-execução-real-em-sandbox) Manus **não apenas guia** — ele **executa** scripts Python/Bash dentro de uma VM Ubuntu isolada: * Browser automation + code execution + file operations integrados * Lê SKILL.md, executa scripts bundled, orquestra workflows completos * Resultados entregues prontos (não instruções para seguir) ### Como compartilhar [Seção intitulada “Como compartilhar”](#como-compartilhar-2) * **Team Skill Library** (Team plan): Publicar skills verificadas para toda a equipe * Skills portáveis via Agent Skills open standard ### Skills vs MCP no Manus [Seção intitulada “Skills vs MCP no Manus”](#skills-vs-mcp-no-manus) | | Skills | MCP | | -------- | --------------------- | ---------------------- | | Objetivo | Encapsular workflows | Conectar data sources | | Função | Playbook — como fazer | Pipeline — onde buscar | | Execução | Scripts diretos | API calls padronizados | *** ## Gemini (Chrome) [Seção intitulada “Gemini (Chrome)”](#gemini-chrome) **URL:** Sidebar Gemini no Chrome → `/` → Skills, ou `chrome://skills/browse` **Planos:** Grátis — qualquer usuário Chrome logado. Não precisa de Google AI Pro. **Requisitos:** Chrome desktop (Mac/Win/ChromeOS), idioma English (US). ### Como criar [Seção intitulada “Como criar”](#como-criar-3) 1. Abra sidebar Gemini no Chrome (ícone “G” no canto superior direito) 2. Faça um prompt que funcione bem 3. Após resposta, clique **“Save as Skill”** 4. Dê nome + emoji → Salvo e sincronizado entre todos os Chrome desktops ### Como usar [Seção intitulada “Como usar”](#como-usar-3) * Abra sidebar → digite `/` → lista de skills aparece → selecione * Ou clique no botão `+` na interface Gemini * **Multi-tab**: Ao triggar skill, selecione múltiplas abas para processar juntas ### Library pré-built [Seção intitulada “Library pré-built”](#library-pré-built) 50+ skills prontas em `chrome://skills/browse` organizadas por: * **Learning** — Resumir artigos, explicar conceitos * **Research** — Cross-reference, fact-check * **Shopping** — Comparar produtos entre abas * **Writing** — Reescrever em diferentes tons * **Productivity** — Resumir documentos, extrair action items ### Diferencial: Multi-tab execution [Seção intitulada “Diferencial: Multi-tab execution”](#diferencial-multi-tab-execution) Nenhuma outra plataforma permite rodar 1 skill em múltiplas abas simultaneamente. Ex: 5 páginas de produto abertas → 1 skill de comparação → resultado consolidado. ### Gerenciar [Seção intitulada “Gerenciar”](#gerenciar) * Digite `/` → ícone bússola para editar/deletar * Ou acesse `chrome://skills/browse` direto na barra de endereço *** ## Perplexity [Seção intitulada “Perplexity”](#perplexity) **URL:** Dentro de Perplexity Computer (Max/Enterprise) + Spaces **Modelo:** Diferente das outras plataformas — não usa SKILL.md. ### Arquitetura em 3 camadas [Seção intitulada “Arquitetura em 3 camadas”](#arquitetura-em-3-camadas) | Camada | Função | | -------------- | ------------------------------------------------------------------------ | | **Connectors** | Integrações com 100+ ferramentas (Gmail, Notion, GitHub, Slack, etc.) | | **Skills** | Capacidades dentro de cada connector (ler emails, enviar, rotular, etc.) | | **Tasks** | Workflows automatizados com trigger → ações → output → error handling | ### Como usar [Seção intitulada “Como usar”](#como-usar-4) * **Skills ativam automaticamente** baseado na query * Acesse via **skills page** no Computer * **Spaces**: Custom instructions + files = funciona como “skill de contexto” * Connectors configurados em Settings ### Limitações [Seção intitulada “Limitações”](#limitações) * Não usa formato SKILL.md (não portável) * Skills são capacidades dentro de connectors, não arquivos markdown * Mais próximo de “Zapier com raciocínio” do que de skills portáveis *** ## Comparativo Detalhado [Seção intitulada “Comparativo Detalhado”](#comparativo-detalhado) | Feature | ChatGPT | Claude | Manus | Gemini | Perplexity | | ------------------- | -------------- | ----------------- | ------------ | ---------------- | -------------- | | Criar via chat | ✅ | ❌ | ✅ | ✅ | ❌ | | Upload SKILL.md | ✅ | ✅ (ZIP) | ✅ | ❌ | ❌ | | Execução de código | ❌ Guia | ✅ Sandbox | ✅ VM Ubuntu | ❌ | ✅ Computer | | Trigger | Auto ou @skill | Auto ou explícito | `/NOME` | `/` + selecionar | Auto por query | | Multi-tab | ❌ | ❌ | ❌ | ✅ | ❌ | | Compartilhar | Workspace | Share → org | Team Library | Sync Chrome | Spaces | | Portável (SKILL.md) | ✅ | ✅ | ✅ | ❌ | ❌ | | Grátis | ❌ (Business+) | ✅ (Free+) | ✅ | ✅ | ❌ (Max) | *** ## Portabilidade entre plataformas [Seção intitulada “Portabilidade entre plataformas”](#portabilidade-entre-plataformas) O formato **SKILL.md** (agentskills.io) é um open standard adotado por \~40 clientes. Isso significa: * Uma skill escrita para Claude pode ser instalada no ChatGPT e no Manus sem alteração * `npx skills add` (skills.sh da Vercel) instala em 20+ agents diferentes * Gemini e Perplexity **não** participam deste ecossistema de portabilidade ### Fluxo prático [Seção intitulada “Fluxo prático”](#fluxo-prático) ```plaintext Criar skill (SKILL.md + scripts) │ ├─→ Upload ZIP no Claude ├─→ Upload no ChatGPT ├─→ Import one-click no Manus └─→ npx skills add (qualquer agent CLI) ``` *** ## Referências [Seção intitulada “Referências”](#referências) * [Skills in ChatGPT — OpenAI Help Center](https://help.openai.com/en/articles/20001066-skills-in-chatgpt) * [Using Skills — OpenAI Academy](https://openai.com/academy/skills/) * [Use skills in Claude — Anthropic Support](https://support.claude.com/en/articles/12512180-use-skills-in-claude) * [Build custom AI workflows — Manus](https://manus.im/features/agent-skills) * [Gemini Skills in Chrome — Google Blog](https://blog.google/products-and-platforms/products/chrome/skills-in-chrome/) * [Agent Skills Open Standard — agentskills.io](https://agentskills.io/home) # Agent Plugin Eval > Audita, pontua e compara repositórios de Agent Plugins portáveis contra a especificação oficial. Scorecard 0–100 com evidências citadas, gate de conformidade e blockers de release. ## Visão Geral [Seção intitulada “Visão Geral”](#visão-geral) Audita repositórios que contêm Agent Plugins portáveis contra a [especificação oficial Agent Plugins](https://agent-plugins.org). Produz um scorecard de 0 a 100 com evidências citadas por `file:line` ou ponteiro JSON, um gate de conformidade (PASS/PARTIAL/FAIL) e a lista de blockers que impedem o release. Avalia **conformidade portável**, não features de um cliente específico. Um manifesto nativo — `.codex-plugin/plugin.json`, `.claude/settings.json`, `.cursor/mcp.json` — não substitui o `plugin.json` obrigatório na raiz. Um plugin excelente para um cliente pode reprovar no padrão portável, e a skill reporta os dois fatos sem tirar média entre eles. ## Quando Usar [Seção intitulada “Quando Usar”](#quando-usar) * Auditar um repositório de plugin antes de publicar * Verificar conformidade de `plugin.json` ou `mcp.json` * Validar Agent Skills incluídos no pacote * Avaliar configuração de MCP servers quanto a portabilidade e segurança * Identificar blockers de release * Comparar dois agent plugins lado a lado ## Instalação [Seção intitulada “Instalação”](#instalação) ```bash npx skills add https://github.com/fabricioctelles/skills -s agent-plugin-eval ``` ## Fronteira de segurança [Seção intitulada “Fronteira de segurança”](#fronteira-de-segurança) Auditoria **puramente estática**. A skill não executa código do plugin, hooks, scripts de instalação, gerenciadores de pacote, MCP servers nem testes em rede sem autorização explícita do usuário. Valores suspeitos de credencial são redigidos no relatório e marcados como *suspected* — um acerto de heurística derruba a nota de segurança e exige revisão, mas sozinho não vira gate `FAIL` de credencial confirmada. ## 18 critérios em 4 eixos [Seção intitulada “18 critérios em 4 eixos”](#18-critérios-em-4-eixos) | Eixo | Critérios | Foco | | -------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------- | | **1 — Conformidade portável** | 4 | Um único `plugin.json` na raiz, schema canônico, modelo de metadados fechado, descoberta em locais fixos e coerência de versão | | **2 — Componentes e integração** | 6 | Conformidade e qualidade dos Agent Skills, validade do `mcp.json`, portabilidade de servidores stdio, transporte remoto, isolamento de extensões | | **3 — Segurança e resiliência** | 4 | Contenção de caminho após resolver symlinks, exposição mínima de segredos, independência entre componentes, instalação sem efeito colateral oculto | | **4 — Qualidade de produto** | 4 | Coesão, documentação, utilidade prática e prontidão para release | Critérios têm peso 1x, 2x ou 3x, e os que não se aplicam entram como `NA` em vez de penalizar. O cálculo é determinístico, via `scripts/score.py`: ```bash python3 scripts/score.py --gate partial 1:90:3 2:80:3 3:NA:2 ``` ## Gates de conformidade [Seção intitulada “Gates de conformidade”](#gates-de-conformidade) | Gate | Quando | Teto da nota | | --------- | --------------------------------------------------------------------------------------------- | ------------ | | `PASS` | Nenhuma violação normativa encontrada | sem teto | | `PARTIAL` | Desvio não-fatal de manifesto, ou componente inválido/ignorado | 59 | | `FAIL` | Falha fatal de manifesto ou raiz de pacote, escape da raiz, ou credencial embutida confirmada | 39 | A nota sem teto continua visível ao lado da nota final, para separar qualidade de design de bloqueio de conformidade. ## Como Funciona [Seção intitulada “Como Funciona”](#como-funciona) ```text 1. resolver a raiz do plugin (local, ou clone raso de URL Git) 2. carregar as regras vigentes (snapshot da 1.0.0, ou spec publicada) 3. inventariar todo caminho do pacote <-- dotfiles, symlinks, ignorados pelo Git 4. varredura determinística (inspect_plugin.py) como pista, não veredito 5. revisar cada skill e cada entrada de mcpServers 6. pontuar com score.py e aplicar o gate ``` Cada achado da varredura é confirmado na fonte antes de entrar no relatório. Um cliente aceitar determinada construção não enfraquece um achado normativo. ## Armadilhas que a skill trata [Seção intitulada “Armadilhas que a skill trata”](#armadilhas-que-a-skill-trata) * O núcleo portável v1 contém exatamente Agent Skills e MCP servers. Hooks, commands, agents, apps e marketplaces são específicos de cliente, a menos que estejam num namespace de extensão válido * `skills/` ou `mcp.json` ausentes não são erro. Um caminho presente com o tipo errado de arquivo é componente inválido * Uma skill inválida não pode ser reportada como se todo componente independente fosse inválido * `${PLUGIN_ROOT}` e `${PLUGIN_DATA}` expandem apenas em `args`, valores de `env` e `cwd` do MCP — nunca em `command`, URLs ou headers ## Fontes [Seção intitulada “Fontes”](#fontes) * [Agent Plugins — especificação oficial](https://agent-plugins.org) * [Agent Skills — especificação](https://agentskills.io/specification.md) 📄 [Documentação completa no GitHub](https://github.com/fabricioctelles/skills/blob/main/skills/agent-plugin-eval/SKILL.md) # Agent Ready — Cloudflare Scanner > Audita sites para compatibilidade com agentes de IA usando o scanner Cloudflare isitagentready.com — 18 checks em 5 categorias. ## Visão Geral [Seção intitulada “Visão Geral”](#visão-geral) Audita qualquer website para compatibilidade com agentes de IA usando o scanner Cloudflare [isitagentready.com](https://isitagentready.com/). Escaneia 18 checks em 5 categorias (Discoverability, Content, Bot Access Control, API/Auth/MCP Discovery, Commerce), atribui um nível (0–5) e gera prompts de correção copy-paste para cada check falhado. ## Quando Usar [Seção intitulada “Quando Usar”](#quando-usar) * Escanear um site para agent readiness * Verificar score de compatibilidade com agentes * Corrigir checks falhados * Implementar MCP Server Card * Adicionar Content Signals * Publicar Agent Skills index * Configurar Markdown for Agents * Batch scan de múltiplos domínios ## Instalação [Seção intitulada “Instalação”](#instalação) ```bash npx skills add https://github.com/fabricioctelles/skills -s agent-ready-cloudflare ``` ## Sub-Skills Incluídas [Seção intitulada “Sub-Skills Incluídas”](#sub-skills-incluídas) Inclui 20 sub-skills de implementação cobrindo: * `robots.txt` e `sitemap` * Markdown for Agents * Content Signals * MCP Server Card * A2A Agent Card * Agent Skills Index * OAuth e WebMCP * E mais… ## Categorias de Auditoria [Seção intitulada “Categorias de Auditoria”](#categorias-de-auditoria) ```mermaid graph TD A[Agent Ready Score] --> B[Discoverability] A --> C[Content] A --> D[Bot Access Control] A --> E[API/Auth/MCP Discovery] A --> F[Commerce] B --> G[Nível 0-5] ``` 📄 [Documentação completa no GitHub](https://github.com/fabricioctelles/skills/blob/main/skills/agent-ready-cloudflare/README.md) # Astro Sites Manager > Skill completa para construir, migrar e manter projetos Astro v7 — ciclo completo de desenvolvimento, migração v6→v7, Starlight, Pagefind, deploy em 8+ plataformas. ## Visão Geral [Seção intitulada “Visão Geral”](#visão-geral) Skill completa para construir, migrar e manter projetos Astro v7. Cobre o ciclo completo: boas práticas, migração v6→v7 com plano estruturado, validação de breaking changes, dev server com modo background para agentes IA, roteamento avançado com `src/fetch.ts`, cache de rotas, Sätteri Markdown, compilador Rust, Starlight docs, Pagefind search, SEO, testes e deploy em 8+ plataformas incluindo Coolify. ## Quando Usar [Seção intitulada “Quando Usar”](#quando-usar) * Construir sites com Astro * Upgrade para Astro v7 * Deploy em Coolify/Vercel/Netlify/Cloudflare * Validar breaking changes na migração * Configurar Starlight docs * Configurar Pagefind search * Usar dev server em modo background como agente IA * Configurar route caching ## Instalação [Seção intitulada “Instalação”](#instalação) ```bash npx skills add https://github.com/fabricioctelles/skills -s astro-sites-manager ``` ## Recursos Principais [Seção intitulada “Recursos Principais”](#recursos-principais) * **Integração MCP Astro Docs** — acesso em tempo real à documentação oficial * **10 arquivos de referência** cobrindo migração, validação, testes, deploy, Starlight e mais * **Guia de deploy Coolify** battle-tested com padrões de 17 projetos * **Feature detection** — recursos v7 ativam somente quando disponíveis (seguro em v6) ## Categorias de Referência [Seção intitulada “Categorias de Referência”](#categorias-de-referência) | Referência | Conteúdo | | -------------- | --------------------------------------------------- | | Migração v6→v7 | Plano estruturado com checklist de breaking changes | | Validação | Patterns deprecated e remoções | | Dev Server | Modo background, JSON logging para agentes | | Routing | `src/fetch.ts`, route caching, Sätteri Markdown | | Starlight | Configuração de docs, sidebar, i18n | | Pagefind | Search estático integrado | | Deploy | 8+ plataformas com configs específicas | | Testing | Vitest, Playwright, CI/CD | ## Plataformas de Deploy [Seção intitulada “Plataformas de Deploy”](#plataformas-de-deploy) Coolify · Vercel · Netlify · Cloudflare Pages · AWS · Fly.io · Railway · Render 📄 [Documentação completa no GitHub](https://github.com/fabricioctelles/skills/blob/main/skills/astro-sites-manager/SKILL.md) # Auth.md > Gere, valide e explique arquivos auth.md — o protocolo aberto que permite agentes AI se registrarem em serviços em nome de usuários. ## Visão Geral [Seção intitulada “Visão Geral”](#visão-geral) O protocolo **auth.md** é um padrão aberto que permite agentes de IA se registrarem em serviços em nome de usuários, sem formulários de signup. Um arquivo Markdown publicado na raiz do serviço (`https://service.com/auth.md`) funciona simultaneamente como documentação legível por humanos e artefato descobrível por agentes em runtime. Estende o RFC 9728 (OAuth 2.0 Protected Resource Metadata) com um bloco `agent_auth` nos metadados do Authorization Server. ## Quando Usar [Seção intitulada “Quando Usar”](#quando-usar) * Tornar sua app agent-ready publicando um `auth.md` * Gerar Protected Resource Metadata (RFC 9728) * Validar um `auth.md` existente contra a especificação * Implementar endpoints de registro de agentes * Entender como o protocolo auth.md funciona * Configurar fluxos de autenticação para agentes ## Instalação [Seção intitulada “Instalação”](#instalação) ```bash npx skills add https://github.com/fabricioctelles/skills -s auth-md ``` ## Fluxos Suportados [Seção intitulada “Fluxos Suportados”](#fluxos-suportados) | Fluxo | Mecanismo | Quando usar | | ------------------ | --------------------------------------------------------- | -------------------------------------------- | | **Agent Verified** | Provider assina um ID-JAG atestando identidade do usuário | JIT provisioning de OIDC/SAML; zero-friction | | **User Claimed** | OTP-based (anonymous start ou email required) | Plataformas sem ID-JAG; self-serve | ## Endpoints do Protocolo [Seção intitulada “Endpoints do Protocolo”](#endpoints-do-protocolo) | Endpoint | Propósito | | ----------------------------------------- | ---------------------------------------------- | | `/.well-known/oauth-protected-resource` | Discovery — resource metadata | | `/.well-known/oauth-authorization-server` | Discovery — AS metadata com bloco `agent_auth` | | `POST /agent/auth` | Registro — despacha por campo `type` | | `POST /agent/auth/claim` | Início de claim (anonymous start) | | `POST /agent/auth/claim/complete` | Verificação OTP | | `POST /agent/auth/revoke` | Revogação | ## Modos de Operação [Seção intitulada “Modos de Operação”](#modos-de-operação) | Modo | Descrição | | ---------- | --------------------------------------------------------- | | `generate` | Cria auth.md + metadata JSON | | `validate` | Verifica auth.md existente (basic ou full com fetch live) | | `explain` | Explica o protocolo sem gerar artefatos | ## Artefatos Gerados [Seção intitulada “Artefatos Gerados”](#artefatos-gerados) 1. **`auth.md`** — Arquivo Markdown com todos os passos do protocolo 2. **`oauth-protected-resource.json`** — JSON para `/.well-known/oauth-protected-resource` 3. **`oauth-authorization-server.json`** — JSON com bloco `agent_auth` completo ## Origem [Seção intitulada “Origem”](#origem) Protocolo criado por [WorkOS](https://workos.com/auth-md). Spec: [github.com/workos/auth.md](https://github.com/workos/auth.md) 📄 [Documentação completa no GitHub](https://github.com/fabricioctelles/skills/blob/main/skills/auth-md/SKILL.md) # Coolify Operator > Operador master do Coolify — plataforma open-source self-hosted de deployment (alternativa ao Heroku/Vercel/Netlify). ## Visão Geral [Seção intitulada “Visão Geral”](#visão-geral) Operador master do Coolify — a plataforma open-source self-hosted de deployment (alternativa ao Heroku/Vercel/Netlify). Gerencia aplicações, servidores, bancos de dados e serviços via API REST e CLI oficial. ## Quando Usar [Seção intitulada “Quando Usar”](#quando-usar) * Conectar a instâncias Coolify * Deploy/restart/stop de aplicações * Gerenciar variáveis de ambiente * Listar servidores e bancos de dados * Monitorar logs de deployment * Gerenciar múltiplos ambientes (dev/staging/prod) * Troubleshoot de conexão e autenticação ## Instalação [Seção intitulada “Instalação”](#instalação) ```bash npx skills add https://github.com/fabricioctelles/skills -s coolify-operator ``` ## Changelog [Seção intitulada “Changelog”](#changelog) **v1.1 (Mar 2026)** * Descrição otimizada para clareza e brevidade * Licença MIT adicionada * Checklist de qualidade com 10 pontos de verificação * Conformidade total com o Guia Oficial Anthropic para Agent Skills 📄 [Documentação completa no GitHub](https://github.com/fabricioctelles/skills/blob/main/skills/coolify-operator/SKILL.md) # DESIGN.md Validator > Valida arquivos DESIGN.md contra a especificação oficial do Google usando o CLI @google/design.md — linter, diff, export e spec. ## Visão Geral [Seção intitulada “Visão Geral”](#visão-geral) Valida arquivos DESIGN.md contra a [especificação oficial do Google](https://github.com/google-labs-code/design.md) usando o CLI `@google/design.md`. Funciona com arquivos locais e URLs remotas. Sempre usa `npx` para rodar a versão mais recente — nunca desatualizado. ## Quando Usar [Seção intitulada “Quando Usar”](#quando-usar) * Validar um DESIGN.md contra a spec (lint) * Verificar contraste WCAG entre cores de componentes * Encontrar referências de tokens quebradas (`{colors.X}` inexistente) * Comparar duas versões de um design system (diff) * Exportar tokens para Tailwind v3/v4 ou W3C DTCG * Auditar schema do frontmatter YAML * Verificar ordem canônica das seções ## Instalação [Seção intitulada “Instalação”](#instalação) ```bash npx skills add https://github.com/fabricioctelles/skills -s design-md-validator ``` ## Comandos Principais [Seção intitulada “Comandos Principais”](#comandos-principais) ### Lint (validar) [Seção intitulada “Lint (validar)”](#lint-validar) ```bash npx @google/design.md lint DESIGN.md ``` Saída JSON com `findings[]` e `summary { errors, warnings, infos }`. ### Diff (comparar versões) [Seção intitulada “Diff (comparar versões)”](#diff-comparar-versões) ```bash npx @google/design.md diff DESIGN.md DESIGN-v2.md ``` ### Export (converter tokens) [Seção intitulada “Export (converter tokens)”](#export-converter-tokens) ```bash npx @google/design.md export --format css-tailwind DESIGN.md npx @google/design.md export --format dtcg DESIGN.md ``` ## Regras de Linting [Seção intitulada “Regras de Linting”](#regras-de-linting) | Regra | Severidade | Verifica | | -------------------- | ---------- | -------------------------------------- | | `broken-ref` | error | Token references que não existem | | `missing-primary` | warning | Sem cor `primary` definida | | `contrast-ratio` | warning | Contraste abaixo de WCAG AA (4.5:1) | | `orphaned-tokens` | warning | Tokens definidos mas não referenciados | | `missing-typography` | warning | Sem tokens de tipografia | | `section-order` | warning | Seções fora da ordem canônica | | `unknown-key` | warning | Possível typo em chaves YAML | ## Ferramentas Oficiais Referenciadas [Seção intitulada “Ferramentas Oficiais Referenciadas”](#ferramentas-oficiais-referenciadas) | Ferramenta | Fonte | Propósito | | ----------------------- | ------------------------------ | -------------------- | | `@google/design.md` CLI | npm / Google Labs | Linter oficial | | `stitch-design-taste` | google-labs-code/stitch-skills | Gerador de DESIGN.md | | `design-md` plugin | google-labs-code/stitch-skills | Extração de tokens | 📄 [Documentação completa no GitHub](https://github.com/fabricioctelles/skills/blob/main/skills/design-md-validator/SKILL.md) # Front-End Checklist (movido) > Esta skill foi aposentada. Use a versão oficial do projeto original com 385 regras. Skill Aposentada Esta skill foi descontinuada. O projeto original agora oferece **385 skills independentes** (uma por regra) cobrindo HTML, CSS, JavaScript, Performance, Acessibilidade, SEO, Segurança, Imagens, Testing, Privacidade e Internacionalização. ## Instale direto da fonte [Seção intitulada “Instale direto da fonte”](#instale-direto-da-fonte) ```bash npx skills add frontendchecklist/skills ``` 👉 **Repositório:** [github.com/thedaviddias/Front-End-Checklist/tree/main/skills](https://github.com/thedaviddias/Front-End-Checklist/tree/main/skills) # GEO Optimization > Otimiza conteúdo digital e estratégias de marketing para motores generativos (LLMs, agentes de IA) maximizando citações em respostas de IA. ## Visão Geral [Seção intitulada “Visão Geral”](#visão-geral) Otimiza conteúdo digital e estratégias de marketing para Generative Engines (LLMs, agentes de IA) para maximizar citações em respostas de IA. ## Quando Usar [Seção intitulada “Quando Usar”](#quando-usar) * Melhorar visibilidade em respostas de IA (ChatGPT, Perplexity, Google AI Overview) * Medir taxa de citação * Alinhar terminologia para LLMs * Auditar páginas para IA * Criar roundups e FAQs otimizados ## Instalação [Seção intitulada “Instalação”](#instalação) ```bash npx skills add https://github.com/fabricioctelles/skills -s geo-optimization ``` ## Fluxo de Trabalho [Seção intitulada “Fluxo de Trabalho”](#fluxo-de-trabalho) ```mermaid graph LR A[Auditoria GEO] --> B[Análise de Terminologia] B --> C[Otimização de Conteúdo] C --> D[Schema/FAQ] D --> E[Validação de Citações] ``` ## Changelog [Seção intitulada “Changelog”](#changelog) **v1.1 (Mar 2026)** * Princípios guia movidos para `references/guiding-principles.md` * Ação padrão explícita (Full GEO Audit) * Checklist de qualidade com checkboxes * Descrição otimizada para concisão 📄 [Documentação completa no GitHub](https://github.com/fabricioctelles/skills/blob/main/skills/geo-optimization/SKILL.md) # Human-AI > Reescreve texto em inglês sem os vícios de escrita de IA — combina detecção de 43 padrões, medição estatística de ritmo e injeção de voz em um processo iterativo. ## Visão Geral [Seção intitulada “Visão Geral”](#visão-geral) Remove sinais de escrita mecânica de textos em inglês e recupera ritmo, precisão e voz. Combina detecção de padrões (43 padrões em 3 tiers), medição estatística de ritmo (burstiness, TTR, entropia) e injeção de voz em uma skill iterativa com scoring. O objetivo é melhorar o texto, não enganar detector: nenhuma reescrita pode garantir que uma ferramenta classificará o resultado como humano, e pontuação de detector automático não é critério de qualidade — essas ferramentas erram muito e penalizam desproporcionalmente quem é neurodivergente e quem não é falante nativo. As métricas estatísticas entram como **proxies mensuráveis de ritmo natural**, não como placar a ser vencido. A pesquisa que sustenta a skill é útil por outro motivo: ela mostra que trocar sinônimo não muda nada, porque o problema está na arquitetura da frase — comprimento, ritmo, estrutura de oração e densidade de informação. Skill-irmã da [`humanizar`](/skills/humanizar/) (PT-BR). Para texto em português, use `humanizar`. ## Quando Usar [Seção intitulada “Quando Usar”](#quando-usar) * Texto em **inglês** parece genérico, bland ou gerado por IA * Pedidos como “humanize”, “de-slop”, “remove AI patterns”, “make it sound human” * Reescrever com voz e personalidade, ou corrigir tom genérico * Pipeline de agentes que gera conteúdo em inglês * Revisar output de outro agente antes de publicar ## Diferenciais [Seção intitulada “Diferenciais”](#diferenciais) | Feature | blader/humanizer | brandonwise/humanizer | **human-ai** | | ------------------- | ---------------- | --------------------- | -------------------------------------- | | Padrões | 29 | 28 + estatísticos | **43 (incl. P31-P43 emergentes 2026)** | | Scoring iterativo | ❌ | ❌ | **✅ 0-100 com loop** | | Script de métricas | ❌ | ❌ | **✅ `scripts/measure.py`** | | Presets de voz | ❌ | ❌ | **7 presets** | | Anti-synonym-swap | ❌ | ❌ | **✅ Reestruturação obrigatória** | | Baselines empíricas | ❌ | Parcial | **✅ SSRN + GPTZero + NeurIPS** | ## Modos de Operação [Seção intitulada “Modos de Operação”](#modos-de-operação) | Modo | Quando usar | Resultado | | ------------- | ----------------------------- | -------------------------------------------- | | `full_mode` | Default — “humanize this” | Métricas + diagnóstico + reescrita + scoring | | `direct_mode` | Pipelines ou “humanize quick” | Versão final + relatório sintético | | `review_mode` | Auditar texto de outro agente | Reescrita agressiva + métricas antes/depois | ## Instalação [Seção intitulada “Instalação”](#instalação) ```bash npx skills add https://github.com/fabricioctelles/skills --skill human-ai ``` ## Pesquisa que Fundamenta [Seção intitulada “Pesquisa que Fundamenta”](#pesquisa-que-fundamenta) | Fonte | Descoberta | | ------------------------- | ----------------------------------------------------------------- | | RAID Benchmark (ACL 2024) | Reestruturação estrutural derruba DetectGPT de 70.3% → 4.6% | | humanizerai.com (2026) | Vocabulary bans PIORAM performance em 43 pontos percentuais | | GPTZero | Burstiness (variância de comprimento de frase) é o sinal primário | | SSRN | TTR humano: 0.553 vs AI: 0.455 | | NeurIPS 2023 | Dimensão intrínseca humana \~9 vs AI \~7.5 | | Washington Post | “It’s not X, it’s Y” = padrão #1 de IA em 328K mensagens | Parte dessa pesquisa foi produzida medindo taxa de bypass em detectores. A skill usa os achados pelo que eles revelam sobre **ritmo e estrutura** — não como meta. Nenhum desses números prova autoria humana, e nenhum deles é usado para decidir o que reescrever. ## Changelog [Seção intitulada “Changelog”](#changelog) **v1.0.1 (ago/2026)** * Posicionamento alinhado ao da `humanizar`: a skill não promete texto “indetectável”, e pontuação de detector automático deixa de ser critério * Métricas estatísticas reposicionadas como proxies de ritmo natural, não como placar * Removida a contraindicação baseada em “texto já validado como humano por detectores” **v1.0 (jul/2026)** * Versão inicial com 43 padrões (P1-P43), incluindo 13 emergentes de 2026 * 3 modos de operação com scoring iterativo (0-100) e fallback de estratégia * 7 presets de voz (Essay, Journalistic, Academic, Corporate, Social, Casual, Legal, Instructional) * `scripts/measure.py` para cálculo determinístico de métricas (zero dependências) * 7 gotchas documentados de falhas operacionais reais * Baselines empíricas calibradas por pesquisa publicada * Cross-reference bidirecional com skill `humanizar` (PT-BR) * Baseada em blader/humanizer, brandonwise/humanizer e Aboudjem/humanizer-skill 📄 [Documentação completa no GitHub](https://github.com/fabricioctelles/skills/tree/main/skills/human-ai) # Humanizar > Reescreve e escreve texto em PT-BR sem os vícios de escrita de IA — 13 perfis de voz, guarda de falso positivo, trava factual e scoring iterativo. ## Visão Geral [Seção intitulada “Visão Geral”](#visão-geral) Remove sinais de escrita mecânica de textos em português brasileiro e recupera ritmo, precisão e voz — sem criar uma história nova. Desde a v1.4, também **escreve do zero**, aplicando o catálogo de padrões como filtro de saída em vez de conserto. O objetivo é melhorar o texto, não enganar detector: nenhuma reescrita pode garantir que uma ferramenta classificará o resultado como humano, e a skill trata pontuação de detector automático como critério inválido — essas ferramentas erram mais contra quem é neurodivergente e quem não é falante nativo. Para textos em inglês, use a skill-irmã [Human-AI](/skills/human-ai/). ## Quando Usar [Seção intitulada “Quando Usar”](#quando-usar) * Texto em PT-BR parece genérico, burocrático ou gerado por IA * Pedidos como “humanizar”, “dar vida”, “tirar cara de IA”, “remover AI slop” * Escrever do zero um texto que uma pessoa vai assinar: post, artigo, e-mail, proposta, release, README, bio * Simplificar linguagem institucional ou técnica para público amplo * Auditar output de outro agente antes de publicar * Pipeline de agentes que precisa de output com linguagem natural e contrato estruturado ## Modos de Operação [Seção intitulada “Modos de Operação”](#modos-de-operação) | Modo | Quando usar | Tentativas | Entrega | | --------------- | ----------------------------------------- | ---------- | ---------------------------------------------- | | `modo_completo` | Default — “humaniza isso” | 3 | Texto final, pontuação e resumo das mudanças | | `modo_direto` | Pipelines de agentes ou “humaniza rápido” | 1 | Texto final e relatório sintético | | `modo_revisão` | Auditar texto de outro agente | 3 | Texto final, diagnóstico e relatório detalhado | | `modo_criacao` | O texto ainda não existe | 2 | Somente o texto final | ## Perfis de Voz [Seção intitulada “Perfis de Voz”](#perfis-de-voz) Treze perfis orientam ritmo e registro, sem autorizar conteúdo novo: Crônica, Jornalístico, Acadêmico, Corporativo Informal, Post de Rede Social, WhatsApp, Jurídico, Didático, **Português Simplificado**, **Assertivo**, **Enxuto**, **Resumo** e Voz Neutra. Sem perfil explícito nem amostra do autor, a skill detecta pelo conteúdo; sem sinal claro, usa voz neutra e apenas remove padrões mecânicos. O perfil **Português Simplificado** aplica sete operações derivadas do projeto PorSimples (NILC/USP) e das técnicas associadas à Lei 15.263/2025 (Política Nacional de Linguagem Simples): divisão de períodos, passiva → ativa, reordenação SVO, substituição de marcadores discursivos, remoção de apostos longos, simplificação lexical e explicitação de sujeito. Simplifica a forma, nunca o raciocínio. Os perfis **Assertivo**, **Enxuto** e **Resumo** formam o grupo de *consumo rápido*: otimizam para absorção pelo leitor, não para autoria. Assertivo abre com a resposta e usa negrito como hierarquia; Enxuto responde em uma linha e não explica o que não foi perguntado; Resumo vira board de status com checklist (✅🟡⬜❔🔴), bloqueio em linha própria e um bloco “Sua vez” com as opções de ação. Os três compartilham um conjunto de regras: passo a passo em lista numerada, fechamento em ação concreta em vez de recapitulação, assunto secundário fora do meio do primeiro, e cláusula de escape quando o usuário pede profundidade. Brevidade comprime a forma, nunca o conteúdo — nenhum aviso, número ou condição de escopo é cortado para caber. ## Como Funciona [Seção intitulada “Como Funciona”](#como-funciona) Processo de nove passos sobre um `texto_fonte` imutável: ```text Triagem obrigatória (recusa bula, contrato, manual de aviação) | v 1. seleção do perfil de voz 2. diagnóstico com pesos 1-3 por categoria 3. remoção de padrões (carrega só as references marcadas) 4. restauração de especificidade 5. aplicação da voz 6. guarda de falso positivo <-- desmarca o que não é IA 7. verificação final (12 itens + 5 de brevidade) 8. avaliação 0-100 em 4 dimensões 9. controle de tentativas e entrega ``` **TRAVA FACTUAL.** Nomes, números, datas, citações, fontes, exemplos, causalidade, modalidade, argumento e código são imutáveis. A skill pode condensar, reorganizar e reformular; não pode acrescentar, retirar ou alterar. Candidata que viole a trava é descartada antes mesmo de ser pontuada. **Guarda de falso positivo.** Antes da verificação final, a skill *desmarca* sinais que não são de IA: gramática impecável, prosa seca, registro jurídico ou acadêmico, travessão de diálogo, conectivo isolado, aspas curvas sozinhas, vírgula correta. E preserva marcas humanas em vez de padronizá-las — contração (`pra`, `tá`, `cê`), regionalismo (`uai`, `oxe`, `tchê`), sentimento misto, autocorreção entre parênteses, variação no tamanho das frases. ## Instalação [Seção intitulada “Instalação”](#instalação) ```bash npx skills add https://github.com/fabricioctelles/skills -s humanizar ``` ## Changelog [Seção intitulada “Changelog”](#changelog) **v1.6 (set/2026)** * Perfil **Direto** renomeado para **Assertivo**. O nome colidia com o `modo_direto`, que é modo de operação e não perfil de voz: o contrato de saída admitia `modo: modo_direto` + `perfil_de_voz: Direto`, duas coisas sem relação com o mesmo nome * Novo bloco **Regras comuns aos perfis de consumo rápido**: modelo do leitor em quatro restrições, passo a passo em lista numerada, fechamento em ação concreta, assunto secundário reposicionado e cláusula de escape valendo para os três perfis * Perfil Enxuto ganha dois sinais de IA: dramatização de erro (“Ops”, “Infelizmente”) e idiomatismo onde cabe a ação literal * Perfil Resumo passa a exigir prazo em unidade concreta quando a fonte fornece — e ❔ quando não fornece, porque prazo inventado é status inventado * Regras adaptadas de [i-have-adhd](https://github.com/ayghri/i-have-adhd) (MIT) **v1.5 (ago/2026)** * Três perfis de **consumo rápido**: Assertivo, Enxuto e Resumo, inspirados no projeto [Attention-Span](https://github.com/alexgreensh/attention-span) * Nova reference `padroes-consumo-rapido.md`: regras de formatação, o que sempre cortar, o que nunca cortar e integração com a TRAVA FACTUAL * Verificação de brevidade no Passo 7 (5 itens): proposições preservadas, warnings não removidos, escopo não generalizado, modalidade preservada e números exatos * Guarda de falso positivo ampliada com seis exceções desses perfis: negrito de lead-in, setas, frases curtas, checklists, listas longas e parágrafos de uma linha * Agora são 13 perfis de voz **v1.4 (ago/2026)** * Novo Passo 6 — guarda de falso positivo, com 18 itens que não devem ser marcados e lista de marcas humanas a preservar; inclui aviso explícito contra pontuação de detector automático * Novo `modo_criacao` para escrita do zero: escrever direto e só depois varrer, começando pelos cinco padrões de maior incidência em texto novo * Cinco padrões novos: fonte inventada (referência *específica* que não existe — nunca consertar, apenas marcar), eco do título, alternativa falsa rejeitada, documentação da versão anterior e máxima de camiseta * Travessão recalibrado de peso 1 para peso 2, com varredura obrigatória por `—`, `–` e `--` antes da entrega e exceções explícitas (diálogo de ficção, amostra do autor) * Suíte de regressão ampliada até T8 **v1.3 (jul/2026)** * Perfil **Português Simplificado** com sete operações do PorSimples (NILC/USP) e Lei 15.263/2025 * Nova reference `padroes-portugues-simplificado.md`: \~50 substituições lexicais, métricas do NILC-Metrix, 15 regras em 3 níveis de prioridade e 4 domínios de aplicação * Agora são 10 perfis de voz **v1.2 (jun/2026)** * Detecção automática de tipo de documento com fallback * Scoring pós-reescrita em dimensões ponderadas e loop iterativo com troca de estratégia * Contrato de saída YAML compatível com orquestradores externos **v1.0 (jun/2026)** * Versão inicial com 3 modos de operação * Catálogo de padrões de AI slop específicos do PT-BR * Guardrails contra invenção de fatos e mudança de argumento ## Créditos e Fontes [Seção intitulada “Créditos e Fontes”](#créditos-e-fontes) A guarda de falso positivo, a lista de marcas humanas, o modo de escrita do zero e cinco padrões foram incorporados de [PedroLLou/humanizador](https://github.com/PedroLLou/humanizador) (MIT), versão em português de [blader/humanizer](https://github.com/blader/humanizer) (MIT), que por sua vez parte de [Wikipedia: Signs of AI writing](https://en.wikipedia.org/wiki/Wikipedia:Signs_of_AI_writing), do WikiProject AI Cleanup. O catálogo original também usa o diretório [tropes.fyi](https://tropes.fyi/directory). Fontes em português por trás dessas adaptações: * Marcelo Sabbatini, [“Texto chocho: como identificar a escrita da IA?”](https://iaedpraxis101.substack.com/p/texto-chocho-como-identificar-a-escrita), IAEdPraxis — origem de “crucial” e “mergulhar” como marcadores em PT-BR, dos adjetivos genéricos, da vírgula de série e do ponto dentro das aspas * Marina Semensato, [“Como saber se um texto foi feito por inteligência artificial?”](https://exame.com/tecnologia/examelab/como-saber-se-um-texto-foi-feito-por-inteligencia-artificial/), Exame — excesso de conectivo, conclusão que repete o texto, trios forçados e “não é X, é Y” * [Inteligência artificial na Wikimedia](https://pt.wikipedia.org/wiki/Intelig%C3%AAncia_artificial_na_Wikimedia), Wikipédia em português — excesso de travessão, excesso de “além disso”, material promocional, aspas curvas e referência inexistente * Pew Research Center, [“How Much of the Internet Is Written With AI?”](https://www.pewresearch.org/data-labs/2026/08/20/how-much-of-the-internet-is-written-with-ai/) (2026) — mede o crescimento do travessão, da vírgula de série e do paralelismo negativo. **A amostra é só de páginas em inglês**, então serve como evidência do mecanismo, não do português **Nível de confiança.** Nenhum padrão isolado prova origem artificial; o sinal está no acúmulo. Têm apoio direto em fonte publicada em português ou em medição divulgada: vocabulário de IA, paralelismo negativo, travessão de aparte, emoji decorativo, aspas curvas, sobra de chatbot, conectivo empilhado, pontuação importada do inglês e fonte inventada. Os demais valem como heurística, não como prova. 📄 [Documentação completa no GitHub](https://github.com/fabricioctelles/skills/blob/main/skills/humanizar/SKILL.md) # LGPD Check > Audita websites para conformidade com a LGPD (Lei 13.709/2018). Gera relatório com score e correções prioritárias. ## Visão Geral [Seção intitulada “Visão Geral”](#visão-geral) Audita websites para conformidade com a Lei Geral de Proteção de Dados (LGPD). Verifica 6 módulos de compliance e gera relatório estruturado com score e ações prioritárias. ## Quando Usar [Seção intitulada “Quando Usar”](#quando-usar) * Auditar um site para conformidade LGPD * Verificar política de privacidade * Checar consentimento de cookies (modelo opt-in) * Validar direitos do titular (DSAR) * Revisar scripts de terceiros e transferência internacional ## Instalação [Seção intitulada “Instalação”](#instalação) ```bash npx skills add lgpd-app/skills --skill "LGPD Check" ``` ## 6 Módulos de Auditoria [Seção intitulada “6 Módulos de Auditoria”](#6-módulos-de-auditoria) | # | Módulo | O que audita | | - | --------------------------- | --------------------------------------------------------------------------- | | 1 | Política de Privacidade | Existência, acessibilidade, identificação do controlador, bases legais, DPO | | 2 | Consentimento de Cookies | Modelo opt-in, banner, botão rejeitar, dark patterns | | 3 | Minimização de Dados | Campos desnecessários, dados sensíveis, proporcionalidade | | 4 | Transferência Internacional | SCCs, adequação, mecanismos legais | | 5 | Direitos do Titular | Canal de exercício, prazo de resposta (15 dias), portabilidade | | 6 | Scripts de Terceiros | Analytics, pixels, CDNs — consentimento necessário | ## Uso [Seção intitulada “Uso”](#uso) ```plaintext auditar LGPD https://exemplo.com.br lgpd check https://exemplo.com.br ``` ## Contexto Regulatório (2026) [Seção intitulada “Contexto Regulatório (2026)”](#contexto-regulatório-2026) * ANPD como agência independente (Resolução 33/2026) * Adequação mútua Brasil-UE (Resolução 32/2026) * SCCs obrigatórias fora do eixo Brasil-UE (Resolução 19/2024) * Sanções: até 2% da receita (teto R$50M por infração) 📄 [Documentação completa no GitHub](https://github.com/lgpd-app/skills) # LGPD.md > Gera e valida arquivos lgpd.md — o padrão aberto de declaração de conformidade LGPD para repositórios e projetos. ## Visão Geral [Seção intitulada “Visão Geral”](#visão-geral) Gera e valida arquivos `lgpd.md` — o padrão aberto de declaração de conformidade LGPD para repositórios e projetos. Análogo ao que `LICENSE` é para licenciamento e `SECURITY.md` para segurança. ## Quando Usar [Seção intitulada “Quando Usar”](#quando-usar) * Gerar um `lgpd.md` para seu projeto/repositório * Validar um `lgpd.md` existente contra a spec * Extrair declaração de conformidade a partir de documentos internos ou política de privacidade ## Instalação [Seção intitulada “Instalação”](#instalação) ```bash npx skills add lgpd-app/skills --skill lgpd-md ``` ## Funcionalidades [Seção intitulada “Funcionalidades”](#funcionalidades) * **Gerar** — cria `lgpd.md` a partir de documentos de conformidade e política de privacidade * **Validar** — verifica estrutura e conteúdo contra a spec do padrão ## Uso [Seção intitulada “Uso”](#uso) ```plaintext gerar lgpd.md validar lgpd.md ``` ## Links [Seção intitulada “Links”](#links) * 🌐 [lgpd.app](https://lgpd.app) * 📄 [Padrão lgpd.md](https://lgpd.md) 📄 [Documentação completa no GitHub](https://github.com/lgpd-app/skills) # Loop Architect > Projete loops agenticos bem estruturados com coaching de boas práticas, gates de revisão cross-model e verificação tipada — depois execute com /goal, subagents ou um runner Python portável. ## O Problema [Seção intitulada “O Problema”](#o-problema) Você quer rodar um loop autônomo de agente — mas o `/goal` aceita qualquer condição que você digitar, por mais vaga que seja. Sem coaching, sem segunda opinião, sem estrutura. O modelo avalia o próprio trabalho. Quando o loop falha ou queima tokens, você não tem nada portável para inspecionar, versionar ou reusar. ## A Solução [Seção intitulada “A Solução”](#a-solução) Loop Architect é um **coach de design** que ajuda você a montar um loop agentico bem-desenhado antes de qualquer runner começar a modificar arquivos. Entrevista você, critica seu design contra rubrics internas, configura um reviewer cross-model, e emite artefatos portáveis. Baseado em [Looper](https://github.com/ksimback/looper) por [Kevin Simback](https://github.com/ksimback), licença MIT. Adaptado para Kiro CLI com integração nativa de `/goal`, subagent e review loops. ## Quando Usar [Seção intitulada “Quando Usar”](#quando-usar) * Projetar um loop agentico com verificação explícita antes de executar * Configurar um loop de self-review ou LLM-as-judge com um modelo diferente como reviewer * Construir um council multi-modelo para gates de plano e entrega * Scaffoldar um processo orientado a `/goal` com verificação tipada e guardas de terminação * Criar specs de loop portáveis que funcionam entre diferentes CLIs ## Instalação [Seção intitulada “Instalação”](#instalação) ```bash npx skills add https://github.com/fabricioctelles/skills -s loop-architect ``` ## Como Funciona [Seção intitulada “Como Funciona”](#como-funciona) ```text +--------------------------------+ | 1. Goal + contexto | | ler fontes | +--------------------------------+ | v +--------------------------------+ | 2. Rascunho plan.md | | state -> state.json | +--------------------------------+ | v +--------------------------------+ | 3. Gate do plano | | veredicto: reviewer-1 | +--------------------------------+ | precisa ajuste -> revisar <= 3 -> step 2 | passou v +--------------------------------+ | 4. Escrever delivery-N.md | | log -> run-log.md | +--------------------------------+ | v +--------------------------------+ | 5. Gate de entrega | | veredicto: reviewer-1 | +--------------------------------+ | precisa ajuste -> revisar <= 3 -> step 4 | passou v +--------------------------------+ | 6. Output final | | todos os gates limpos | +--------------------------------+ Para: gates OK | max iterações | sem progresso x2 | cap de budget ``` ### A entrevista em sete estágios [Seção intitulada “A entrevista em sete estágios”](#a-entrevista-em-sete-estágios) 1. **Goal** — guiado para outcome, escopo, contexto e estado final 2. **Verificação** — tipada como programática, judge ou humana 3. **Modelo host** — qual CLI dirige o loop 4. **Council** — reviewer/judge de uma família de modelo diferente 5. **Gates & controle** — caps de revisão, detecção de no-progress, budget 6. **Confirmação** — preview ASCII do fluxo 7. **Emitir/rodar** — escrever artefatos e opcionalmente executar ### Três caminhos de execução [Seção intitulada “Três caminhos de execução”](#três-caminhos-de-execução) | Caminho | Quando | Como | | --------------------- | ------------------------------------ | -------------------------------------------------------- | | `/goal` | Loop simples, sem review cross-model | `/goal --max 12 ` | | Pipeline de subagents | Review cross-model necessário | Review loops nativos do Kiro com trigger `NEEDS_CHANGES` | | Runner Python | Externo, agendado ou CI | `python3 ./loop-architect-output/run-loop.py` | ## Artefatos Emitidos [Seção intitulada “Artefatos Emitidos”](#artefatos-emitidos) | Arquivo | Propósito | | -------------------- | ------------------------------------------ | | `loop.yaml` | Spec do loop (autoria humana) | | `loop.resolved.json` | Compilado, validado — o runner lê isso | | `LOOP.md` | Resumo legível + flow ASCII | | `RUN_IN_SESSION.md` | Prompt de handoff para execução in-session | | `run-loop.py` | Runner Python portável | | `loop-workspace/` | Diretório de trabalho com state e logs | ## Detecção de Modelos [Seção intitulada “Detecção de Modelos”](#detecção-de-modelos) Loop Architect detecta CLIs instaladas e suas capacidades: ```bash python3 ~/.kiro/skills/loop-architect/scripts/looper.py detect-models ``` Kiro CLI é detectado com todas as capacidades: `headless`, `goal`, `subagent`, `review_loop`. ## vs /goal e Ralph Loop [Seção intitulada “vs /goal e Ralph Loop”](#vs-goal-e-ralph-loop) | | `/goal` | Ralph Loop | **Loop Architect** | | ------------------ | -------- | --------------------- | --------------------------------- | | Camada | execução | execução (spec tasks) | **design (pré-voo)** | | Coacheia goal | não | não | **sim** | | Verificação tipada | não | auto-correção | **programática / judge / humana** | | Review cross-model | não | não | **sim, por padrão** | | Artefato portável | não | não | **loop.yaml + spec compilada** | 📄 [Documentação completa no GitHub](https://github.com/fabricioctelles/skills/blob/main/skills/loop-architect/SKILL.md) # OKF — Open Knowledge Format > Cria, valida e enriquece bundles no formato Open Knowledge Format (OKF) — a especificação aberta para representar conhecimento organizacional como arquivos Markdown com YAML frontmatter. ## Visão Geral [Seção intitulada “Visão Geral”](#visão-geral) O **Open Knowledge Format (OKF)** é uma spec vendor-neutral (v0.1, anunciada 12 Jun 2026 por Sam McVeety & Amir Hormati, Google Cloud) que formaliza o pattern “LLM Wiki” num formato portável e interoperável. Representa conhecimento como diretório de arquivos Markdown com YAML frontmatter. Não requer SDK — se você consegue ler um `.md`, consegue ler OKF. Cada arquivo = um “conceito” (tabela, métrica, playbook, API endpoint, etc.). A estrutura é um bundle (diretório) com conceitos interligados via links Markdown padrão. O Google Cloud Knowledge Catalog ingere bundles OKF nativamente. ## Quando Usar [Seção intitulada “Quando Usar”](#quando-usar) * Criar uma base de conhecimento para agentes de IA * Converter documentação existente para formato OKF * Validar bundles OKF contra a especificação * Enriquecer docs Markdown com frontmatter padronizado * Estruturar wikis ou knowledge bases como arquivos interoperáveis * Tornar conhecimento organizacional agent-readable * Enviar bundles para o Knowledge Catalog via kcmd CLI/MCP ## Instalação [Seção intitulada “Instalação”](#instalação) ```bash npx skills add https://github.com/fabricioctelles/skills -s okf-open-knowledge-format ``` ## Campos do Frontmatter [Seção intitulada “Campos do Frontmatter”](#campos-do-frontmatter) | Campo | Obrigatório? | Descrição | | ------------- | ------------ | ---------------------------------------------------------------------------- | | `type` | **SIM** | Tipo do conceito (texto livre: `BigQuery Table`, `Metric`, `Playbook`, etc.) | | `title` | Recomendado | Nome legível para humanos | | `description` | Recomendado | Resumo em uma frase | | `resource` | Recomendado | URI identificando o asset subjacente | | `tags` | Opcional | Lista YAML para categorização transversal | | `timestamp` | Opcional | Datetime ISO 8601 da última mudança relevante | ## Estrutura de um Bundle [Seção intitulada “Estrutura de um Bundle”](#estrutura-de-um-bundle) ```plaintext meu-bundle/ ├── index.md ├── log.md ├── tables/ │ ├── index.md │ ├── users.md │ └── orders.md ├── metrics/ │ └── revenue.md └── playbooks/ └── onboarding.md ``` ## Modos de Operação [Seção intitulada “Modos de Operação”](#modos-de-operação) | Modo | Descrição | | ---------- | -------------------------------------------------------------- | | `create` | Cria bundle OKF do zero a partir de descrição | | `convert` | Converte diretório de Markdown existente para OKF conformant | | `validate` | Verifica conformidade com a spec (3 regras) | | `enrich` | Adiciona frontmatter faltante, schema, citations e cross-links | | `serve` | Envia bundles pro Knowledge Catalog via kcmd push | ## Integração com Knowledge Catalog [Seção intitulada “Integração com Knowledge Catalog”](#integração-com-knowledge-catalog) O Knowledge Catalog do Google Cloud ingere OKF nativamente. A skill sabe usar o `kcmd` (CLI + MCP server) pra push/pull de bundles, permitindo que qualquer agente MCP-compatible acesse o catálogo. ## Origem [Seção intitulada “Origem”](#origem) Spec criada por Sam McVeety & Amir Hormati (Google Cloud, 12 Jun 2026). Formaliza o pattern “LLM Wiki” ([gist do Karpathy](https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f)) num formato interoperável. Licença Apache 2.0. 📄 [Documentação completa no GitHub](https://github.com/fabricioctelles/skills/tree/main/skills/okf-open-knowledge-format) | 🌐 [okf.md](https://okf.md) # Pier Cloud API > Guia completo para consumo da API Pier Cloud (Lighthouse) com autenticação, gerenciamento de contextos, workspaces e views de dados FinOps. ## Visão Geral [Seção intitulada “Visão Geral”](#visão-geral) Guia completo para consumo da API [Pier Cloud](https://piercloud.com/en/) (Lighthouse) com autenticação, gerenciamento de contextos, workspaces e visualizações de dados. ## Quando Usar [Seção intitulada “Quando Usar”](#quando-usar) * Autenticar com Pier Cloud * Listar contextos disponíveis (AWS, etc) * Gerenciar workspaces * Acessar views de análise de custos * Executar scripts FinOps ## Instalação [Seção intitulada “Instalação”](#instalação) ```bash npx skills add https://github.com/fabricioctelles/skills -s pier-cloud ``` ## Recursos [Seção intitulada “Recursos”](#recursos) * Scripts Python para consumo da API * Referência completa da API REST * Guia de troubleshooting * Checklist de qualidade ## Changelog [Seção intitulada “Changelog”](#changelog) **v1.1 (Mar 2026)** * Descrição reescrita para formato de trigger em terceira pessoa * Seção de pré-requisitos corrigida * Linguagem convertida para forma imperativa * Links de workflow corrigidos para `references/REFERENCE.md` * Checklist de qualidade adicionado 📄 [Documentação completa no GitHub](https://github.com/fabricioctelles/skills/blob/main/skills/pier-cloud/SKILL.md) # Pstack Skill > Orquestrador de engenharia rigorosa portado do pstack da Lauren Tan (poteto-mode) como uma única skill autocontida — 23 playbooks, 21 procedures e 21 princípios, sem plugin e sem depender do Cursor. ## O Problema [Seção intitulada “O Problema”](#o-problema) Agentes de IA escrevem código rápido — e frequentemente slop. Sem um método, o agente “chuta” a implementação sem entender o sistema, entrega sem verificar comportamento real, empilha mudanças não testadas e para para perguntar coisas que um experimento responderia. Throughput sem qualidade não é meta: você quer menos código, mas melhor. O [pstack](https://github.com/cursor/plugins/tree/main/pstack) da Lauren Tan (@poteto) resolve isso — mas era um plugin exclusivo do Cursor, com instalação via marketplace, cloud agents, Graphite e slugs de modelo proprietários. ## A Solução [Seção intitulada “A Solução”](#a-solução) Pstack Skill é o porte **autocontido** do pstack completo para uma única skill compatível com skills.sh. Um orquestrador que: * lê sua tarefa e escolhe um dos **23 playbooks** (bug fix, feature, refactoring, perf, investigation, prototype, babysit, shipping, autonomous run, orchestrate…); * copia os passos do playbook verbatim para uma todolist antes de raciocinar sobre a tarefa; * roteia para **21 procedures embutidas** conforme os passos disparam (`how`, `why`, `architect`, `arena`, `swarm`, `interrogate`, `unslop`, `technical-writing`, `show-me-your-work`…); * aplica e cita **21 princípios de engenharia**, cada citação rastreável até uma decisão real; * verifica no artefato real — roda a feature como um usuário, nunca confia em “compilou”; * é sticky: uma vez invocada, permanece ativa entre turnos, aplicando-se quando há rigor necessário e saindo do caminho caso contrário. Baseado no [pstack](https://github.com/cursor/plugins/tree/main/pstack) por [Lauren Tan](https://x.com/poteto), licença MIT, com referência ao porte [open-pstack](https://github.com/ericlitman/open-pstack). Mecânicas específicas do Cursor foram traduzidas para equivalentes agnósticos de plataforma. ## Quando Usar [Seção intitulada “Quando Usar”](#quando-usar) * Mudanças de código não triviais, decisões de arquitetura ou “temos certeza?” * Debug com disciplina científica: reproduzir → causa raiz → failing-test-first * Reviews adversariais multi-modelo antes de shipar design contestado * PRs que precisam chegar a merge-ready (conflitos, review threads, CI instável) * Trabalho longo ou autônomo (“vou dormir, termina isso”) com trilha auditável * Programas multi-dia com dezenas de subagentes sob um coordenador ## Instalação [Seção intitulada “Instalação”](#instalação) ```bash npx skills add https://github.com/fabricioctelles/skills -s pstack-skill ``` Ou manual: copie a pasta `skills/pstack-skill/` para `.claude/skills/`, `.cursor/skills/`, `.kiro/skills/` ou o diretório equivalente do seu agente. ## Como Funciona [Seção intitulada “Como Funciona”](#como-funciona) ```text tarefa em linguagem natural | v +---------------------------+ | orquestrador (SKILL.md) | lê os 21 princípios | escolhe o playbook | abre todolist +---------------------------+ | v +---------------------------+ +--------------------+ | playbook (23 opções) | --> | procedures (21) | | passos verbatim na lista | | how/arena/swarm/ | +---------------------------+ | interrogate/unslop | | +--------------------+ v +---------------------------+ | verificação no artefato | superfície real, nunca proxy | trilha de decisões (TSV) | audível depois +---------------------------+ | v PR merge-ready ``` ## Papéis de Modelo [Seção intitulada “Papéis de Modelo”](#papéis-de-modelo) Delegações nunca citam vendors. Quatro papéis com contrato de capacidade, vinculados uma vez em `.agents/pstack-models.md`: | Papel | Contrato | Trabalho típico | | --------- | --------------------------------------------------- | -------------------------------- | | `worker` | rápido, barato, segue instruções mecânicas | edits triviais, explorers, swarm | | `builder` | melhor instruction-follower, contexto longo | implementação especificada | | `judge` | raciocínio mais profundo + prosa calibrada | síntese, reviews, cross-judge | | `peer` | raciocinador forte **de outra família** que o judge | diversidade de painel | Um único modelo disponível? Todos colapsam para ele e painéis viram passes independentes em contexto fresco — nenhum gate de verificação é pulado. ## Os Playbooks [Seção intitulada “Os Playbooks”](#os-playbooks) | Cenário | Playbooks | | ------------------------ | ---------------------------------------------------------------- | | Entender antes de mexer | Investigation, Runtime forensics, Trace forensics | | Construir | Feature, Prototype, Refactoring, Visual parity, Multi-phase plan | | Corrigir cientificamente | Bug fix, Perf issue, Hillclimb | | Shippar PRs | Babysit, Shipping, Opening a PR, Autopilot-full, Autopilot-stack | | Autonomia auditável | Autonomous run, Orchestrate, Session pickup, Pause safely | | Agent tooling | Authoring-a-skill, Eval, Worktree cleanup | ## Destaques [Seção intitulada “Destaques”](#destaques) * **Repro-first**: bug que você não reproduz é bug que você não prova que corrigiu * **Green ≠ safe**: shipping só depois de veredicto independente por PR, pousando apenas a sequência verificada contígua a partir da raiz * **Never block on the human**: trabalho reversível prossegue; pergunta só o que nenhum experimento resolve * **Trilha de decisões**: TSV append-only com evidência por linha, revisada por modelo diferente antes de entregar ## Compatibilidade [Seção intitulada “Compatibilidade”](#compatibilidade) Funciona em Claude Code, Codex, Cursor, opencode, Kiro e qualquer agente que leia SKILL.md no formato skills.sh — com um ou vários modelos, com ou sem CLIs alternativos. # Ralph Loop for Kiro Specs > Leve specs criadas no Kiro IDE até a implementação completa via kiro-cli — um loop auto-corretivo que executa tasks uma a uma, aprende com erros e nunca repete o mesmo problema. ## O Problema [Seção intitulada “O Problema”](#o-problema) Você desenhou a spec no Kiro IDE — requirements, design, tasks, tudo estruturado. Agora precisa implementar. Task por task, prompt por prompt, revisando cada saída manualmente. Com 15 tasks, são 15 ciclos de copiar prompt, colar no terminal, verificar resultado, corrigir erro, tentar de novo. E quando o agente comete o mesmo erro na task 8 que já tinha cometido na task 3? Você corrige de novo. E de novo na task 12. ## A Solução [Seção intitulada “A Solução”](#a-solução) Ralph Loop pega as specs que você criou no Kiro IDE e as executa automaticamente via `kiro-cli`. Um comando, e ele implementa task por task até o fim — ou até você mandar parar. A diferença: Ralph **aprende com os próprios erros**. Se a task 3 descobre que o projeto usa `npm run test:unit` em vez de `npm test`, a task 4 já sabe disso antes de começar. Correções são registradas imediatamente e relidas em cada iteração. Baseado em [ralph-loop-kiro-specs](https://github.com/mreferre/ralph-loop-kiro-specs) por [mreferre](https://github.com/mreferre), licenciado sob Apache License 2.0. ## Quando Usar [Seção intitulada “Quando Usar”](#quando-usar) * Specs prontas no Kiro IDE que precisam ser implementadas via CLI * Projetos com muitas tasks onde execução manual é repetitiva * Specs onde o agente precisa respeitar padrões do codebase existente * Situações onde erros se repetem entre tasks e você quer que o agente pare de cometê-los ## Instalação [Seção intitulada “Instalação”](#instalação) ```bash npx skills add https://github.com/fabricioctelles/skills -s ralph-loop-kiro-specs ``` ## Como Funciona [Seção intitulada “Como Funciona”](#como-funciona) Um comando inicia o loop. Cada iteração implementa exatamente uma task — nunca mais, nunca menos. ```mermaid graph LR A[1. Load Context] --> B[2. Pick ONE Task] B --> C[3. Understand] C --> D[4. Implement] D --> E[5. Verify Exit Criteria] E --> F[6. Update Tracking] F -->|Tasks remain| B F -->|All complete| G[Generate Dashboard] ``` ### O que acontece em cada iteração [Seção intitulada “O que acontece em cada iteração”](#o-que-acontece-em-cada-iteração) 1. **Load Context** — Lê README, docs, steering files e a spec completa 2. **Pick ONE Task** — Encontra a próxima task incompleta. Uma por vez, sem atalhos 3. **Understand** — Lê o código existente, estuda padrões, e relê todas as correções acumuladas 4. **Implement** — Implementa a task e subtasks. Se algo falha, registra a correção na hora 5. **Verify** — Confirma cada critério de saída antes de marcar como concluída 6. **Track** — Marca `[X]`, registra progresso, padrões descobertos e tempo gasto ### O sistema de auto-correção [Seção intitulada “O sistema de auto-correção”](#o-sistema-de-auto-correção) Cada erro vira uma entrada no `progress.md`: ```plaintext - ❌ `npm test` → ✅ `npm run test:unit` (projeto usa scripts separados) - ❌ import sem extensão → ✅ `from 'lib/index.js'` (ESM exige extensão explícita) ``` A próxima iteração lê essa lista antes de tocar em qualquer código. Erros não se repetem. ### Ao final: um dashboard [Seção intitulada “Ao final: um dashboard”](#ao-final-um-dashboard) Quando todas as tasks estão concluídas, Ralph gera um `summary.html` com status geral, árvore de tasks com detalhes por hover, e tabela de timing por task. ## Uso [Seção intitulada “Uso”](#uso) ```bash ./ralph-loop-kiro-specs-script.sh ``` | Argumento | Descrição | | ---------------- | --------------------------------------------------------------------------------------- | | `max_iterations` | Quantas iterações no máximo. Defina pelo menos o número de tasks + margem para retries. | | `specs_name` | Nome do diretório da spec em `.kiro/specs/` | ```bash # Implementar a spec "auth-feature" em até 15 iterações ./ralph-loop-kiro-specs-script.sh 15 auth-feature ``` Você escolhe entre modo **automático** (tasks rodam sem pausa) ou **manual** (pausa entre cada task para revisão). ## Pré-requisitos [Seção intitulada “Pré-requisitos”](#pré-requisitos) * [Kiro CLI](https://kiro.dev/cli/) (`kiro-cli`) instalado e no `PATH` * [Kiro IDE](https://kiro.dev/) instalado * Bash shell * Specs em `.kiro/specs//` com `requirements.md`, `design.md` e `tasks.md` 📄 [Documentação completa no GitHub](https://github.com/fabricioctelles/skills/blob/main/skills/ralph-loop-kiro-specs/SKILL.md) # Resume ATS Beater > Reescreve currículos do zero para compatibilidade ATS e impacto com recrutadores, com workflow adaptado para plataformas brasileiras. ## Visão Geral [Seção intitulada “Visão Geral”](#visão-geral) Reescreve currículos do zero para compatibilidade ATS e impacto com recrutadores, com workflow adaptado para plataformas ATS do Brasil (Gupy, Vagas.com, PandaPé, Sólides). ## Quando Usar [Seção intitulada “Quando Usar”](#quando-usar) * Otimizar currículo para ATS * Adaptar CV para uma vaga/indústria alvo * Melhorar bullets de experiência com resultados mensuráveis * Validar requisitos eliminatórios e matching semântico ## Instalação [Seção intitulada “Instalação”](#instalação) ```bash npx skills add https://github.com/fabricioctelles/skills -s resume-ats-beater ``` ## Fluxo de Trabalho [Seção intitulada “Fluxo de Trabalho”](#fluxo-de-trabalho) ```mermaid graph LR A[Currículo Atual] --> B[Diagnóstico ATS] B --> C[Análise Avançada] C --> D[Reescrita Completa] D --> E[Validação Final] ``` ## Changelog [Seção intitulada “Changelog”](#changelog) **v1.2 (Mar 2026)** * Etapas diagnósticas mescladas em passo único * Templates de output movidos para 3 arquivos de referência * Modo padrão explícito (`modo_completo`) * Guardrail: bloqueia workflow até `curriculo_atual` ser fornecido * Instrução de skip: `modo_reescrita` pula diagnóstico 📄 [Documentação completa no GitHub](https://github.com/fabricioctelles/skills/blob/main/skills/resume-ats-beater/SKILL.md) # Revenue-Centric Design > 101 princípios com evidência para fazer SaaS converter, reter e monetizar — landing pages, onboarding, churn, pricing, behavioral science e diferenciação na era da IA. ## Visão Geral [Seção intitulada “Visão Geral”](#visão-geral) Playbook de 101 princípios extraídos dos posts de Richard ([@richardrx](https://x.com/richardrx), ex-Volkswagen, PayPal, IBM) sobre design de produto orientado a receita. A filosofia: toda decisão de design serve o usuário **e** o negócio — valor e receita, nunca um ou o outro. Cada princípio nomeia o mecanismo (efeito decoy, Zeigarnik, Schwartz, loss aversion…), descreve o movimento concreto e linka de volta ao post original. ## Quando Usar [Seção intitulada “Quando Usar”](#quando-usar) * Landing page não converte — precisa de diagnóstico com base em evidência * Onboarding com ativação baixa — usuários entram e somem * Churn subindo — retenção caindo sem explicação clara * Pricing confuso — não sabe como montar tiers ou usar ancoragem * Posicionamento genérico — ICP indefinido, value prop que não gruda * Quer o mecanismo comportamental por trás de uma decisão de design * Diferenciação na era IA — tudo parece commodity ## A Espinha Dorsal: RCD em 9 Princípios [Seção intitulada “A Espinha Dorsal: RCD em 9 Princípios”](#a-espinha-dorsal-rcd-em-9-princípios) 1. **Neutralidade é omissão** — interface que não direciona mata conversão. 2. **Quem fala com todos não convence ninguém** — sem ICP → valor genérico → churn. 3. **Valor primeiro, pedido depois** — prova antes de o usuário questionar a escolha. 4. **Sua promessa é do tamanho da sua prova** — o mercado acredita no que você demonstra. 5. **Igual compete em preço, diferente compete em categoria** — contraste em mecanismo, narrativa ou experiência. 6. **Default é a decisão que você tomou pelo usuário** — estado inicial define comportamento de massa. 7. **Retenção se constrói, não se pede** — perda percebida retém mais que benefício prometido. 8. **Expansão nasce do uso** — upgrade no momento do limite, nunca por interrupção. 9. **Preço é filtro** — pricing define quem entra, quem fica e quem expande. ## Biblioteca de Referência [Seção intitulada “Biblioteca de Referência”](#biblioteca-de-referência) | Área | Arquivo | | --------------------------------------------------------- | ---------------------------------- | | Landing pages, hero, CTAs, social proof, awareness levels | `conversion-and-landing-pages.md` | | First-run, empty states, aha moment, TTV, trial | `onboarding-and-activation.md` | | Cancelamento, retenção, expectation debt, NRR | `churn-and-retention.md` | | Pricing tables, decoy/anchoring, GBB, upgrade paths | `pricing-and-monetization.md` | | Vieses cognitivos e táticas de persuasão | `behavioral-science-toolkit.md` | | Feature scope, Swiss Knife Index, hierarquia de atenção | `product-strategy-and-features.md` | | Filosofia RCD, princípios, processo de design | `revenue-centric-design.md` | | ICP, nicho, founder-fit, distribuição, PLG | `positioning-icp-and-gtm.md` | | Diferenciação na era IA, moats, commoditização | `ai-era-differentiation.md` | | A/B testing rigor, vanity metrics, churn→LTV math | `metrics-and-experimentation.md` | ## Scripts Inclusos [Seção intitulada “Scripts Inclusos”](#scripts-inclusos) * **`revenue_math.py`** — cálculos de sample size para A/B, churn→LTV, CAC por deal fechado. Não estima — calcula. * **`check_usage_boundary.py`** — guardrail que bloqueia uso em contexto de gambling/betting/casino (restrição de licença do autor). ## Guardrail de Uso [Seção intitulada “Guardrail de Uso”](#guardrail-de-uso) > 🚫 Esta skill **não pode** ser aplicada a produtos de apostas, cassino, gambling ou jogos de azar com dinheiro real. Restrição do autor original, não uma preferência estilística. O script `check_usage_boundary.py` roda como hook automatizado em agentes compatíveis. ## Memória por Projeto [Seção intitulada “Memória por Projeto”](#memória-por-projeto) A skill mantém um log local (`rcd-log.md`) que registra quais princípios foram aplicados, quando e qual foi o resultado. Evita repetir o que já falhou e rastreia o que funciona. ## Instalação [Seção intitulada “Instalação”](#instalação) ```bash npx skills add https://github.com/fabricioctelles/skills -s revenue-centric-design ``` ## Origem [Seção intitulada “Origem”](#origem) Richard publicou os 101 princípios como posts em português no X. [Helio Costa](https://github.com/heliocosta-dev) obteve permissão, extraiu via API do X, traduziu para inglês e estruturou a [skill original](https://github.com/heliocosta-dev/revenue-centric-design). Esta versão evoluiu com: audit template, scripts de cálculo, project log, gotchas, guardrails e avaliação via [Skill Evaluation](/skills/skill-evaluation/) (60→73 pontos). ## Skills Relacionadas [Seção intitulada “Skills Relacionadas”](#skills-relacionadas) RCD fornece o **princípio e a evidência** — skills de execução cuidam do workflow: * Auditoria de página → [CRO](https://github.com/coreyhaines31/marketingskills) * Cancellation flow → Churn Prevention * Estatísticas de teste → A/B Testing * Copy da página → Copywriting * Pricing page → Pricing * Pós-signup → Onboarding ## Changelog [Seção intitulada “Changelog”](#changelog) **v1.0.0 (Jul 2026)** * 101 princípios organizados em 10 arquivos de referência temáticos * Scripts: `revenue_math.py` (sample size, churn→LTV, CAC) + `check_usage_boundary.py` (guardrail) * Audit template para entregas estruturadas * Project log (`rcd-log.md`) para memória entre sessões * Gotchas: escassez real, loss aversion vs dark pattern, kill outbound links (só LP), 4.2–4.5 stars * Hooks documentados como SOP (agentes com/sem suporte) * Licença source-available com restrição de gambling 📄 [Documentação completa no GitHub](https://github.com/fabricioctelles/skills/blob/main/skills/revenue-centric-design/SKILL.md) # Security Specialist > Agente completo de segurança de aplicações — SAST, DAST, pentest, threat model, triagem e remediação com pipeline de 6 fases e validação adversarial. ## Visão Geral [Seção intitulada “Visão Geral”](#visão-geral) Agente completo de segurança de aplicações — executa SAST (análise estática), DAST (testes dinâmicos), threat modeling, triagem de vulnerabilidades, remediação e penetration testing. Combina revisão de código com testes ao vivo para correlação completa de evidências. ## Quando Usar [Seção intitulada “Quando Usar”](#quando-usar) * Auditoria de segurança completa de repositório * Revisão de PR/diff para regressões de segurança * Pentest de aplicações web * Construir threat model * Triar e priorizar vulnerabilidades * Corrigir vulnerabilidades com patches verificados * Exportar findings para GitHub/Jira/Linear * Gerar relatório HTML interativo ## Funcionalidades Principais [Seção intitulada “Funcionalidades Principais”](#funcionalidades-principais) ### Pipeline de 6 Fases (Full-Scan) [Seção intitulada “Pipeline de 6 Fases (Full-Scan)”](#pipeline-de-6-fases-full-scan) | Fase | O que faz | | ----------- | ------------------------------------------------------------------------------------ | | 1. Recon | Agentes paralelos mapeiam arquitetura, trust boundaries e input surfaces | | 2. Hunt | Agentes paralelos por attack class (9 categorias) com 12 ângulos de hunting | | 3. Validate | Validação adversarial — agentes separados tentam DISPROVAR cada finding | | 4. Report | HTML auto-contido com dark theme, filtros e evidência colapsável | | 5. Schema | findings.json validado contra JSON schema (trace, conditions, execution, confidence) | | 6. Verify | Verificação independente de cada claim factual por agentes frescos | ### 9 Attack Classes [Seção intitulada “9 Attack Classes”](#9-attack-classes) Injection, Access Control, Resource/File Handling, Cryptography, Business Logic, Feature Abuse, Chained Attacks, Wildcard, Obvious Things. ### 12 Workflows [Seção intitulada “12 Workflows”](#12-workflows) full-scan, diff-review, pentest, hunting, threat-model, attack-paths, discovery, triage, remediation, tracking, validation, reporting. ### Multi-Run Additive Coverage [Seção intitulada “Multi-Run Additive Coverage”](#multi-run-additive-coverage) Cada run targeta gaps dos runs anteriores. Um single run encontra \~50% do total de vulnerabilidades. ## Instalação [Seção intitulada “Instalação”](#instalação) ```bash npx skills add https://github.com/fabricioctelles/skills -s security-specialist ``` ## Changelog [Seção intitulada “Changelog”](#changelog) **v2.0 (Jun 2026)** * Pipeline de 6 fases com agentes paralelos (inspirado no Cloudflare security-audit-skill) * 9 attack classes e hunting methodology de 12 ângulos * Validação adversarial (Phase 3) e verificação independente (Phase 6) * JSON schema para findings estruturados com trace, conditions, execution, confidence * Validador de schema zero-deps (Node.js) para integração CI * Multi-run additive coverage * 10 anti-patterns a evitar * Calibração de baseline dinâmico na severity policy **v1.0 (Jun 2026)** * 11 steering workflows modulares * Scripts Python (SQLite, ranker, pentest, finalizer) * HTML report auto-contido com dark theme * Pentest tool cascade * Three-layer correlation (source → dev → prod) 📄 [Documentação completa no GitHub](https://github.com/fabricioctelles/skills/blob/main/skills/security-specialist/SKILL.md) # Skill Evaluation > Avalia skills de agentes IA contra 12 critérios de boas práticas (Anthropic + agentskills.io). Produz scorecard com notas, grade e ações de melhoria. ## Visão Geral [Seção intitulada “Visão Geral”](#visão-geral) Avalia qualquer skill de agente contra 12 critérios de boas práticas definidos pela Anthropic e agentskills.io. Produz um scorecard markdown estruturado com notas por critério (0–100), classificação por categoria, bonus patterns e ações priorizadas. ## Quando Usar [Seção intitulada “Quando Usar”](#quando-usar) * Avaliar qualidade de uma skill antes de publicar * Auditar skills existentes para identificar melhorias * Comparar duas skills lado a lado * Verificar compliance com best practices da indústria ## Instalação [Seção intitulada “Instalação”](#instalação) ```bash npx skills add https://github.com/fabricioctelles/skills -s skill-evaluation ``` ## 12 Critérios Avaliados [Seção intitulada “12 Critérios Avaliados”](#12-critérios-avaliados) | # | Critério | Peso | | -- | ------------------------- | ---- | | 1 | Não diga o óbvio | 2x | | 2 | Seção de Gotchas | 2x | | 3 | Progressive disclosure | 2x | | 4 | Evita railroading | 1x | | 5 | Setup flow | 1x | | 6 | Descrição para trigger | 2x | | 7 | Mecanismo de memória | 1x | | 8 | Scripts & libraries | 1x | | 9 | On-demand hooks | 1x | | 10 | Concisão | 2x | | 11 | Escopo coerente | 1x | | 12 | Baseado em expertise real | 2x | ## 4 Bonus Patterns (medidos, sem impacto na nota) [Seção intitulada “4 Bonus Patterns (medidos, sem impacto na nota)”](#4-bonus-patterns-medidos-sem-impacto-na-nota) * Validation loops * Output templates * Procedures over declarations * Defaults over menus ## Diferença do agentskills.io evals [Seção intitulada “Diferença do agentskills.io evals”](#diferença-do-agentskillsio-evals) | | Skill Evaluation | agentskills.io evals | | ------ | -------------------------- | ------------------------------ | | Avalia | Qualidade da **estrutura** | Qualidade do **output** em uso | | Método | Inspeção estática | Test cases + benchmark | | Quando | A skill está bem escrita? | A skill funciona na prática? | | Saída | Scorecard 0-100 + grade | pass\_rate + tokens + time | Use esta skill primeiro para estrutura sólida, depois [rode evals](https://agentskills.io/skill-creation/evaluating-skills) para validar performance. ## Exemplo de Saída [Seção intitulada “Exemplo de Saída”](#exemplo-de-saída) ```markdown # Skill Evaluation — skill-evaluation > Evaluated: 2026-06-27 > Evaluator: skill-evaluation v1.0.0 ## Summary | Metric | Value | |--------|-------| | Overall Score | 62/100 | | Grade | B | | Category | code-quality-and-review | | Files | 2 | | Has references/ | yes | | Has scripts/ | no | ## Scorecard | # | Criterion | Score | Notes | |---|-----------|-------|-------| | 1 | Don't state the obvious | 85 | Framework é específico, não genérico | | 2 | Gotchas section | 0 | Ausente — sem aviso de pitfalls | | 3 | Progressive disclosure | 55 | 1 reference file, template inline | | 6 | Description for trigger | 90 | Múltiplos triggers concretos | | 10 | Conciseness | 70 | 223 linhas, output template poderia ser ref | | 11 | Coherent scope | 95 | Faz UMA coisa bem | | 12 | Grounded in expertise | 80 | 3 fontes autoritativas | ## Top 3 Improvements 1. Gotchas (0) — Adicionar pitfalls de avaliação multi-client 2. Scripts (0) — Criar quick-check.sh para critérios mensuráveis 3. Memory (0) — Manter evaluations.log para tracking de progresso ``` ## Fontes [Seção intitulada “Fontes”](#fontes) * [Lessons from building Claude Code: How we use skills](https://claude.com/blog/lessons-from-building-claude-code-how-we-use-skills) * [Best practices for skill creators](https://agentskills.io/skill-creation/best-practices) * [Evaluating skill output quality](https://agentskills.io/skill-creation/evaluating-skills) 📄 [Documentação completa no GitHub](https://github.com/fabricioctelles/skills/blob/main/skills/skill-evaluation/SKILL.md) # Slop Eval > Avalia objetivamente design de UI/web contra a lei anti-slop do pols.dev — detecta tells catalogados com evidência citada, pontua 8 eixos ponderados e emite um Slop Report com Slop Index 0–100 e nota. ## Visão Geral [Seção intitulada “Visão Geral”](#visão-geral) Avalia um design da mesma forma que `skill-evaluation` avalia uma skill: cada achado cita evidência concreta, cada eixo recebe nota 0–100, a aritmética é executada por script, e a saída é um relatório estruturado — nunca um “vibe check”. Baseado na [lei anti-slop do pols.dev](https://pols.dev/slop.md) — catálogo de tells, regras absolutas e fórmula de assinatura destilados dela. ## Quando Usar [Seção intitulada “Quando Usar”](#quando-usar) * Avaliar se um design parece genérico/gerado por IA * Pedidos como “slop report”, “is this AI slop”, “audit this landing page design”, “de-slop review” * Score objetivo de quão templated/machine-made um design parece * Gate de qualidade em CI (bloquear PR se Slop Index > threshold) * Antes de entregar design para cliente ou publicar * Acompanhar evolução do design ao longo do tempo (Tracking Mode) > Para texto (não design), use [`human-ai`](/skills/human-ai/) (EN) ou [`humanizar`](/skills/humanizar/) (PT-BR). ## Instalação [Seção intitulada “Instalação”](#instalação) ```bash npx skills add https://github.com/fabricioctelles/skills -s slop-eval ``` ## Novidades na v1.1.0 (Ago 2026) [Seção intitulada “Novidades na v1.1.0 (Ago 2026)”](#novidades-na-v110-ago-2026) ### Section Ledger [Seção intitulada “Section Ledger”](#section-ledger) Vereditos por seção do design com bandas de densidade de tells: | Veredito | Tells | Significado | | ---------- | ------------------- | ------------------------ | | CLEAN | 0–1 | Pode aprovar | | SUSPICIOUS | 2–3 | Revisar antes de aprovar | | INFLATED | 4–6 | Redesenhar seção | | CRITICAL | ≥7 ou qualquer crit | Refazer do zero | ### Design Contexts [Seção intitulada “Design Contexts”](#design-contexts) Avaliação context-aware para 4 tipos de design: | Contexto | Tells Prioritários | Tolerâncias | | ------------------ | ------------------------ | ------------------------------ | | **Landing Page** | L1, L2, S1, C1, K9, L4 | K2, K14 (se deadline real), L9 | | **SaaS Dashboard** | X1, X3, K6, K22, L3, L15 | K1, K13, T4, K7 (se UI real) | | **Editorial** | T1, T2, T3, L7, W2, L10 | C7, L5, K21, T6 | | **E-commerce** | X3, X5, K23, W3, M8, L3 | K14, K22, K17, L12 | ### Sistema de Exclusões [Seção intitulada “Sistema de Exclusões”](#sistema-de-exclusões) Tags formalizadas para documentar tells excluídos: | Tag | Quando usar | | --------------------- | --------------------------------------------- | | `// BRIEF:` | Cliente/stakeholder direcionou explicitamente | | `// DESIGN DECISION:` | Decisão de design documentada com reasoning | | `// CONTEXT:` | Contexto do design torna o padrão aceitável | | `// PREMIUM PAIR:` | É a versão premium, não a versão slop | ### Tracking Mode [Seção intitulada “Tracking Mode”](#tracking-mode) Análise de evolução temporal com: * Tabela de progressão de scores com tendências (✅/⚠️) * Tells resolvidos (o que foi corrigido) * Tells novos (o que foi introduzido) * Regressões (eixos/seções que pioraram) * Métricas de velocidade (tells resolvidos por semana) * Recomendações para próxima iteração ```bash # Primeira avaliação — estabelece baseline slop-eval --target https://site.com --output ./reports/baseline.md # Avaliação posterior — acompanha evolução slop-eval --target https://site.com --output ./reports/week-2.md \ --compare ./reports/baseline.md ``` ### Adding Soul Guide [Seção intitulada “Adding Soul Guide”](#adding-soul-guide) Guia de prescrição para injetar personalidade em cada eixo — não só “remova tell X” mas “substitua por alternativa premium Y”: | Eixo | Genérico | Com alma | | ----------- | -------------------------- | -------------------------------------- | | Cor | Paleta de UI kit | Uma cor inesperada com razão | | Tipografia | Inter/Space Grotesk | Face com opinião (Gambarino, Reckless) | | Componentes | Lucide icons em tiles | Ícones bespoke em estilo próprio | | Layout | Stack de hero centralizado | Composição assimétrica | | Motion | Fade-in no scroll | Micro-interação authored | ### Quality Checklist Expandido [Seção intitulada “Quality Checklist Expandido”](#quality-checklist-expandido) 25+ checks em 6 fases: * **Pre-sweep:** inventário de evidência, brief documentado, contexto identificado * **During-sweep:** cite-or-cut, premium pair checado, testes de portabilidade e defesa * **Exclusão:** tags documentadas, exclusões genuínas, contagem razoável * **Post-sweep:** checks unverifiable marcados, regras absolutas, gates aplicados * **Relatório:** template seguido, fixes rankeados por impacto * **Self-audit:** “O que ainda parece slop que não flaggeei?” ## 8 Eixos Avaliados [Seção intitulada “8 Eixos Avaliados”](#8-eixos-avaliados) | # | Eixo | Peso | Avaliado por | | - | ----------------------- | ---- | ---------------------- | | 1 | Cor & Luz | 2x | Tells C1–C15 | | 2 | Tipografia & Copy | 2x | Tells T1–T10, W1–W3 | | 3 | Componentes & Ornamento | 1x | Tells K1–K27 | | 4 | Layout & Composição | 2x | Tells L1–L21 | | 5 | Motion & Interação | 1x | Tells M1–M8 | | 6 | Execução & Craft | 2x | Tells X1–X14 | | 7 | Assinatura & Unicidade | 3x | Fórmula de 7 elementos | | 8 | Coesão | 2x | 4 verificações | ## Escala de Notas [Seção intitulada “Escala de Notas”](#escala-de-notas) | Nota | Overall | Slop Index | Veredito | | ---- | ------- | ---------- | ----------------------------------------- | | A | 80–100 | 0–20 | Premium — deliberado, assinado, executado | | B | 60–79 | 21–40 | Considerado — majoritariamente deliberado | | C | 40–59 | 41–60 | Genérico — limpo mas templated | | D | 20–39 | 61–80 | Slop — montado de presets | | F | 0–19 | 81–100 | Slop puro | ## 6 Regras Absolutas [Seção intitulada “6 Regras Absolutas”](#6-regras-absolutas) Cada uma é pass/fail — falha é um tell crítico que dispara gate: 1. **Conteúdo visível por padrão** — nada gated em animação de entrada 2. **Sem cortes** — nenhum texto/controle cortado por clip, notch ou overflow 3. **Alinhamento paralelo** — colunas comparáveis compartilham baselines 4. **Centralização real** — tudo que deveria estar centrado está (matemática e ótica) 5. **Contraste legível** — todo texto supera o background por gap real 6. **Controles funcionam** — todo elemento interativo responde ## Canais de Evidência [Seção intitulada “Canais de Evidência”](#canais-de-evidência) | Canal | Pode verificar | Não pode verificar | | --------------------- | ---------------------------------------------- | ------------------------------------------------------ | | Código (CSS/JSX/HTML) | Fonts, hex, gradients, shadows, radii, layout | Centralização ótica, contraste renderizado, interações | | Screenshot(s) | Tudo visual: paleta, tipo, layout, alinhamento | Hover/scroll motion, controles mortos | | URL ao vivo | Tudo acima + interações, motion, fold | Apenas o que não exercitou | ## Gates (Caps) [Seção intitulada “Gates (Caps)”](#gates-caps) * **Signature gate:** Eixo 7 < 40 → cap overall em 59 (nota C máx). Design limpo sem assinatura ainda é slop. * **Absolute-rule gate:** qualquer tell crítico confirmado → cap overall em 69 (nunca nota A com execução quebrada). * **Compounding cap:** ≥3 tells major de layout → cap Eixo 4 em 40. ## Integração CI [Seção intitulada “Integração CI”](#integração-ci) .github/workflows/slop-gate.yml ```yaml - name: Slop gate run: | python3 skills/slop-eval/scripts/score.py overall \ 1:$A1:2 2:$A2:2 3:$A3:1 4:$A4:2 5:$A5:1 6:$A6:2 7:$A7:3 8:$A8:2 \ --fail-below 40 ``` ## Fontes [Seção intitulada “Fontes”](#fontes) * [The pols.dev anti-slop design law](https://pols.dev/slop.md) * Método modelado na [skill-evaluation](https://github.com/fabricioctelles/skills/tree/main/skills/skill-evaluation) 📄 [Documentação completa no GitHub](https://github.com/fabricioctelles/skills/blob/main/skills/slop-eval/SKILL.md) # Startup Idea > Análise completa de startups com mentalidade Paul Graham + Dan Koe + Seth Godin — pressure test, monetização, MVA, remarkability e plano de ação. ## Visão Geral [Seção intitulada “Visão Geral”](#visão-geral) Analista de startups que combina três lentes complementares: * **Paul Graham / YC** — pressão estratégica, verdade desconfortável, founder-market fit, early users e validação brutal do problema * **Dan Koe** — clareza de monetização, oferta, distribuição, conteúdo e crescimento sustentável * **Seth Godin** — remarkability, smallest viable audience, narrativa, símbolos memoráveis e diferenciação A missão não é elogiar ideias. É produzir uma leitura completa do negócio apontando o que é forte, o que é fraco e o que precisa acontecer para virar uma empresa real. ## Quando Usar [Seção intitulada “Quando Usar”](#quando-usar) * “Tenho uma ideia de startup” * “Será que minha ideia funciona?” * “Como validar minha ideia” * “Como conseguir meus primeiros usuários” * Validação de negócio, posicionamento, MVP, modelo de receita * GTM, growth engine, pricing, moat, unit economics * Pressure test, branding, narrativa, diferenciação ## Instalação [Seção intitulada “Instalação”](#instalação) ```bash npx skills add https://github.com/fabricioctelles/skills -s startup-idea ``` ## Estrutura da Análise (13 Passos) [Seção intitulada “Estrutura da Análise (13 Passos)”](#estrutura-da-análise-13-passos) ```mermaid graph TD A[0. Coleta de Contexto] --> B[1. Diagnóstico Executivo] B --> C[2. Pressure Test da Tese] C --> D[3. Problema e Early Adopter] D --> E[4. Mercado e Timing] E --> F[5. Mapeamento Competitivo] F --> G[6. Modelo de Negócio] G --> H[7. Oferta e Posicionamento] H --> I[8. MVA e Remarkability] I --> J[9. Primeiros 10 Clientes] J --> K[10. MVP em 2 Semanas] K --> L[11. Distribuição e Vendas] L --> M[12. Motor de Crescimento] M --> N[13. Riscos, Moat e Decisão] ``` ## Parâmetros [Seção intitulada “Parâmetros”](#parâmetros) | Parâmetro | Descrição | Padrão | | --------- | ------------------------------------------------- | ---------- | | `idea` | Descrição da startup ou hipótese | Perguntar | | `stage` | `idea`, `validation`, `mvp`, `traction`, `growth` | Inferir | | `depth` | `quick`, `standard`, `full` | `standard` | ## Formato de Saída [Seção intitulada “Formato de Saída”](#formato-de-saída) **Standard/Full** — Relatório completo com 9 seções + Plano de 30 Dias + Perguntas em Aberto **Quick** — Leitura rápida com: o que é, o que preocupa, o que valida/invalida, próxima ação ## Princípios [Seção intitulada “Princípios”](#princípios) 1. A startup precisa resolver uma dor real, específica e recorrente 2. A maior concorrência é quase sempre o status quo 3. Founder-market fit importa 4. Distribuição não é detalhe 5. Monetização precisa fazer sentido cedo 6. Ser diferente de verdade importa 7. Especificidade vence alcance 📄 [Documentação completa no GitHub](https://github.com/fabricioctelles/skills/blob/main/skills/startup-idea/SKILL.md) # Substack Expert > Especialista na plataforma Substack — formatação de posts, SEO, engajamento com Notes/Chat e conversão para assinaturas pagas. ## Visão Geral [Seção intitulada “Visão Geral”](#visão-geral) Especialista na plataforma Substack. Guia formatação de posts, otimização de SEO (títulos, slugs, meta descriptions), estratégias de engajamento nativas (Notes, Chat) e conversão para assinaturas pagas. ## Quando Usar [Seção intitulada “Quando Usar”](#quando-usar) * Formatar e otimizar posts no Substack * Melhorar SEO da newsletter (títulos, slugs, meta descriptions) * Crescer audiência com Notes e recomendações * Converter leitores gratuitos em assinantes pagos * Customizar homepage e emails de boas-vindas ## Instalação [Seção intitulada “Instalação”](#instalação) ```bash npx skills add https://github.com/fabricioctelles/skills -s substack-expert ``` ## Changelog [Seção intitulada “Changelog”](#changelog) **v1.1 (Mar 2026)** * Seção Overview duplicada removida * Dicas de formatação movidas para `references/formatting-best-practices.md` * Exemplos de I/O movidos para `references/seo-output-example.md` * Tabela de parâmetros com defaults * Checklist de qualidade com 8 pontos de verificação 📄 [Documentação completa no GitHub](https://github.com/fabricioctelles/skills/blob/main/skills/substack-expert/SKILL.md) # Ultimate Design System Master > Gera entregáveis de design de nível Apple/Pentagram/Vercel/Figma usando 10 prompts especializados por papel. ## Visão Geral [Seção intitulada “Visão Geral”](#visão-geral) Gera entregáveis de design de nível Apple/Pentagram/frog/Vercel/Figma usando 10 prompts especializados por papel. Cobre Design Systems, Brand Identity, UI/UX Patterns, Marketing Assets, Figma Specs, Design Critique, Trend Analysis, Accessibility Audit, Design-to-Code e Executive Presentations. ## Quando Usar [Seção intitulada “Quando Usar”](#quando-usar) * Criar um design system * Construir identidade de marca * Gerar padrões UI/UX * Produzir assets de marketing * Escrever specs para Figma * Obter crítica de design * Analisar tendências de design * Auditar acessibilidade * Traduzir design para código * Criar decks de apresentação ## Instalação [Seção intitulada “Instalação”](#instalação) ```bash npx skills add https://github.com/fabricioctelles/skills -s ultimate-design-system-master ``` ## Changelog [Seção intitulada “Changelog”](#changelog) **v2.2 (Mar 2026)** * Descrição reescrita com frases de trigger do usuário * Licença Apache 2.0 adicionada * Conformidade total com o Guia Oficial Anthropic para Agent Skills **v2.1 (Mar 2026)** * Questionário de briefing com 18 perguntas movido para `references/` * Checklist de qualidade com 5 condições de verificação 📄 [Documentação completa no GitHub](https://github.com/fabricioctelles/skills/blob/main/skills/ultimate-design-system-master/SKILL.md) # Website Spec (movido) > Esta skill foi aposentada. Use a skill oficial do specification.website. Skill Aposentada Esta skill foi descontinuada. O projeto original agora oferece uma skill mais completa com **140+ tópicos**, atualizações live via MCP server, re-audits incrementais e integração com MDN. ## Use a skill oficial [Seção intitulada “Use a skill oficial”](#use-a-skill-oficial) 👉 **SKILL.md:** [specification.website/.well-known/agent-skills/specification-website/SKILL.md](https://specification.website/.well-known/agent-skills/specification-website/SKILL.md) 👉 **MCP endpoint:** `https://mcp.specification.website/mcp` 👉 **Site:** [specification.website](https://specification.website/)