Communitygithub.com

ASoudy/AGS

Use quando receber um plano de implementação detalhado de uma IA de fronteira para executar dentro do OpenCode com modelos de codificação não-fronteira. Valida o plano em relação ao repositório real, divide em etapas seguras, verifica cada etapa, inspeciona diffs e previne alterações destrutivas. É acionado ao receber um plano de várias etapas do Claude Opus/GPT-5/etc., executar uma especificação pré-escrita, implementar uma descrição detalhada de PR, ou ao ser instruído a "executar este plano passo a passo".

O que é AGS?

Este skill, **Frontier Plan OpenCode Executor**, é projetado para agentes de codificação não-fronteira (como modelos menores) executarem planos detalhados de implementação gerados por IAs de fronteira (ex.: Claude Opus, GPT-5) de forma segura e verificada dentro do OpenCode. Ele aborda a fragilidade comum desses planos, como nomes de arquivos inexistentes, importações inventadas ou bibliotecas indisponíveis, forçando uma validação rigorosa contra o repositório real antes de qualquer edição. O fluxo de trabalho inclui uma fase de pré-voo para estabelecer a linha de base do repositório, extração e verificação de realidade de cada etapa, criação de um rastreador de progresso (com `todowrite` ou checklist manual), implementação incremental com verificação em camadas (lint, typecheck, testes), inspeção de diff, e um relatório final. O skill também gerencia automaticamente commits e pushes, segue Conventional Commits, e lida com falhas repetidas de forma estruturada, exigindo que o agente forme novas hipóteses em vez de aplicar correções cegas. Ele suporta os principais editores de código com IA (OpenCode, Cursor, Codex, Claude Code) e é essencial para garantir que planos ambiciosos de IAs de fronteira sejam executados com segurança, sem danificar o código existente.

Funciona com✓Claude Code~Codex CLI~Cursor✓Gemini CLI✓OpenCode
npx skills add https://github.com/ASoudy/AGS/tree/HEAD/claude_skills_libraries/landing-page-mastery/skills/frontier-plan-opencode-executor

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Executor de Planos de Fronteira OpenCode

Princípio Central

O plano de fronteira é uma hipótese forte, não a verdade absoluta.

Execute a intenção do plano passo a passo, mas valide cada instrução em relação ao repositório real antes de editar o código. Planos de IA de fronteira falham frequentemente em: nomes de arquivo inexistentes, importações inventadas, bibliotecas indisponíveis, padrões que não correspondem ao repositório, testes ausentes, arquitetura idealizada e quebra de APIs internas.

Nunca agrupe grandes alterações. Nunca pule a verificação. Nunca esconda incertezas. Nunca realize ações destrutivas sem aprovação explícita.

Quando Usar

  • Você recebe um plano de implementação detalhado e com várias etapas escrito por uma IA de fronteira
  • O plano tem 3+ etapas distintas com caminhos de arquivo e padrões de código específicos
  • Você está usando um modelo de codificação não-fronteira que se beneficia de disciplina de execução
  • O plano apresenta risco de conflito com a base de código real

NÃO use para:

  • Alterações de arquivo único ou correções triviais
  • Planos com apenas 1-2 etapas simples
  • Planos que você mesmo escreveu durante a mesma sessão
  • Iteração rápida onde o usuário prioriza velocidade sobre segurança

Fluxo de Trabalho Central

0. PRÉ-VOO: Estabelecer Linha de Base do Repositório

Antes de tocar em qualquer arquivo, entenda o estado do repositório e detecte falhas pré-existentes.

1. git status --short          # O repositório está limpo?
2. Inspecione package.json         # Scripts disponíveis, dependências
3. Inspecione AGENTS.md, README.md # Convenções do projeto, comandos
4. Detecte comandos de verificação disponíveis a partir dos scripts do package.json
5. Execute a verificação de linha de base mais barata se disponível (lint ou typecheck)

Se a linha de base já falhar:

  • Registre a falha explicitamente: comando exato, status de saída e resumo curto do erro
  • NÃO tente limpeza ampla ou corrigir problemas não relacionados
  • Continue apenas se a alteração planejada puder ser isolada da falha existente
  • Não atribua falhas pré-existentes à sua implementação

Detecção de estado perigoso:

  • Se git status mostrar alterações não confirmadas não relacionadas ao plano, avise o usuário
  • Se os lockfiles forem modificados, avise o usuário
  • Se o repositório estiver em estado de conflito/rebase, pare e pergunte

Recomendação de checkpoint:

  • Se o repositório estiver limpo antes de começar, recomende criar um commit de checkpoint antes da implementação
  • NÃO crie commits a menos que o usuário peça explicitamente

Auto-Commit e Auto-Push

Auto-commit e auto-push estão habilitados por padrão, a menos que o usuário os desabilite explicitamente.

O agente deve confirmar (commitar) cada unidade lógica de trabalho verificada e fazer push para o branch de trabalho ativo remoto para que o usuário possa revisar o histórico posteriormente.

Antes da implementação:

  • identifique o branch atual;
  • se estiver em main, master, production, release ou outro branch protegido/principal, crie um novo branch de trabalho inferido do plano;
  • se já estiver em um branch de trabalho, continue nele;
  • nunca faça push diretamente para branches protegidos/principais.

Se houver alterações não confirmadas pré-existentes:

  • não as inclua automaticamente nos commits do agente;
  • prepare apenas os arquivos relacionados à unidade lógica atual;
  • se as alterações do usuário e do agente não puderem ser separadas com segurança, pare e relate o conflito.

Faça commit somente após:

  • a unidade lógica estar completa;
  • a verificação passar;
  • o diff ter sido inspecionado;
  • o commit ter um propósito coerente.

Use Conventional Commits:

tipo(escopo): resumo imperativo conciso

Exemplos:

feat(auth): adicionar helper de validação de sessão
fix(api): tratar payload de webhook vazio
refactor(billing): extrair mapeador de fatura
test(auth): cobrir fluxo de sessão expirada

1. ANALISAR: Extrair e Verificar a Realidade do Plano

Leia o plano INTEIRO. Extraia as etapas ordenadas. Para cada etapa, execute uma verificação de realidade:

VerificaçãoPergunta
ArquivosOs arquivos referenciados existem no repositório?
BibliotecasAs bibliotecas referenciadas estão no package.json?
PadrõesO repositório já possui um utilitário/componente equivalente?
ComandosOs comandos de verificação do plano estão disponíveis?
DependênciasEsta etapa depende de uma etapa anterior?
RiscoBaixo / Médio / Alto — qual a probabilidade de quebrar o comportamento existente?

Se uma etapa referenciar arquivos ausentes, bibliotecas inexistentes, padrões desatualizados ou comandos indisponíveis: adapte a etapa antes de implementar, preservando a intenção do plano.

2. RASTREAR: Criar Rastreador de Progresso

Use todowrite (ferramenta de lista de tarefas do OpenCode) se disponível.

Se todowrite não estiver disponível (por exemplo, em subagentes onde está desabilitado por padrão):

  • Crie uma checklist em markdown visível em sua resposta
  • Mantenha-a atualizada manualmente após cada etapa
  • Use-a como fonte da verdade para o progresso
  • NÃO finja que a ferramenta foi usada se não foi

Cada item deve incluir: a ação de implementação, o método de verificação e os arquivos esperados que serão tocados.

3. IMPLEMENTAR: Uma Etapa de Cada Vez

Marque a etapa atual como em_andamento. Implemente APENAS essa etapa.

  • Leia os arquivos de destino antes de editar
  • Siga as convenções existentes da base de código (importações, nomenclatura, padrões, arquitetura)
  • Adapte o plano à infraestrutura existente (por exemplo, se o plano diz "criar um componente de toast" mas o projeto usa Sonner, envolva o Sonner em vez de construir do zero)
  • Faça a menor alteração coerente
  • NÃO implemente etapas futuras, mas mantenha as dependências downstream em mente ao tomar decisões de design
  • NÃO realize limpeza, refatoração ou formatação não relacionada
  • NÃO instale dependências a menos que aprovado explicitamente

4. VERIFICAR: Verificação em Camadas

Após cada etapa, execute a verificação significativa mais restrita. Não execute "lint em tudo" toda vez.

Tipo de AlteraçãoVerificação MínimaVerificação Mais Forte
Novo arquivo/componentelint ou typechecktypecheck afetado
Alteração de tipo/interfacetypechecktestes afetados
Alteração de lógica/funçãoteste unitário direcionadosuíte de testes completa
Alteração de API/servidorteste de integração direcionadobuild + verificação de endpoint
Alteração de UItypecheck + buildverificação visual/manual smoke
Alteração de configuração/buildbuildinstalação/build limpa se necessário
Alteração de banco de dados/esquemacomando de dry-run/verificaçãoaprovação do usuário necessária

Se nenhuma verificação automatizada existir para uma etapa: realize uma revisão manual e declare precisamente o que você verificou.

Se a verificação falhar:

Primeira falha — corrija e re-verifique:

  • Corrija apenas os erros causados pela etapa atual
  • NÃO corrija erros pré-existentes ou não relacionados
  • Re-verifique imediatamente

Falhas repetidas — não continue aplicando correções cegamente. Veja "Tratamento de Falhas Repetidas" abaixo.

Crítico: Nunca faça a verificação passar enfraquecendo asserções, excluindo testes, removendo comportamento, alterando APIs públicas, suprimindo erros ou escondendo falhas — a menos que o plano exija explicitamente E o usuário aprove. Fazer o alarme parar não é o mesmo que corrigir o problema.

5. DIFF: Inspecionar Alterações

Após a verificação passar, inspecione o que realmente mudou:

git diff --stat          # Quais arquivos mudaram?
git diff                 # Quando o diff for pequeno o suficiente para revisar

Confirme:

  • Apenas os arquivos esperados foram alterados
  • Nenhuma formatação não relacionada ocorreu
  • Nenhum lockfile foi alterado (a menos que explicitamente intencionado)
  • Nenhum arquivo gerado foi editado acidentalmente
  • Nenhum segredo, caminho local ou log de depuração foi introduzido
  • Nenhum código foi acidentalmente excluído

Se o diff exceder o escopo esperado, pare e corrija antes de continuar.

6. CONFIRMAR: Marcar como Completo

Somente quando a implementação, verificação E inspeção de diff estiverem limpas:

  • Marque a etapa como concluída
  • Resuma o que mudou em uma frase
  • Marque a próxima etapa como em_andamento

7. FINAL: Verificação Completa + Relatório

Após todas as etapas:

  • Execute a verificação razoável mais forte: lint + typecheck + build + testes (usando comandos do projeto)
  • Relate: etapas concluídas, arquivos alterados, resultados de verificação, adaptações feitas, falhas pré-existentes (se houver), algo que precise de revisão do usuário

Tratamento de Falhas Repetidas

Se a verificação falhar repetidamente pela mesma causa subjacente, não continue aplicando pequenas correções cegas. O objetivo é detectar se você está aprendendo algo novo entre as tentativas ou apenas fazendo alterações aleatórias.

Quando uma etapa falha várias vezes:

  1. Pare de corrigir. Pare de fazer pequenos ajustes e re-executar.
  2. Re-leia a saída do erro com cuidado. O stacktrace completo, não apenas a primeira linha.
  3. Inspecione o diff e o código ao redor. git diff, leia tipos, interfaces, funções relacionadas.
  4. Re-avalie a suposição original. A estratégia de implementação atual está correta?
  5. Classifique a falha:
    • Suposição incorreta sobre a base de código?
    • Incompatibilidade do repositório (plano vs realidade)?
    • Abstração errada escolhida?
    • Incompatibilidade de interface ou tipo?
    • Dependência ausente?
    • Artefatos gerados desatualizados?
    • Problema pré-existente não relacionado à sua alteração?
    • O próprio comando de verificação está mal configurado?
  6. Forme uma hipótese genuinamente nova. Tente novamente somente quando tiver uma.
  7. Considere reduzir o escopo. A etapa pode ser dividida em pedaços menores para isolar a falha?

Regra crítica: Não repita a mesma estratégia de correção a menos que novas informações tenham sido descobertas a partir de:

  • Logs
  • Stack traces
  • Diffs
  • Testes
  • Inspeção do repositório
  • Documentação

Se nenhuma nova estratégia surgir após várias tentativas, pare e relate o bloqueador claramente:

Bloqueador:
- comando de verificação: `npm run build`
- arquivo com falha: `src/app/page.tsx`
- hipótese da causa raiz: Componente React Server importando hook exclusivo de cliente
- estratégias tentadas:
  1. movido import para componente cliente
  2. isolado hook em arquivo separado
  3. verificados padrões existentes no repositório
- motivo para parar:
  nenhum padrão consistente no repositório para resolver a fronteira com segurança
- próxima ação provável:
  revisão do usuário ou esclarecimento arquitetural

Um relatório de bloqueador claro é sempre melhor do que repetir "ainda falhando" enquanto chuta.

Adaptando Planos ao Código Existente

Planos de IA de fronteira frequentemente conflitam com a base de código real. Quando isso acontecer:

  1. Identifique o conflito — "O plano diz import { X } from 'lib-nao-instalada' mas não está no package.json"
  2. Adapte, não ignore — Use a infraestrutura existente para corresponder à intenção do plano
  3. Explique a adaptação — Uma frase sobre o que você mudou e por quê
  4. Preserve a interface do plano — Se o plano exporta useToast(), sua adaptação ainda deve exportar useToast(), mesmo que os internos difiram

Regras críticas:

  • NÃO crie novas abstrações se o repositório já tiver um primitivo equivalente
  • NÃO instale novas dependências a menos que o plano exija explicitamente E o usuário aprove
  • NÃO altere arquitetura ou padrões sem justificativa

Proibido Sem Aprovação Explícita do Usuário

Estes comandos exigem que o usuário diga "sim" antes de executar:

Destrutivos:

  • rm -rf
  • git reset --hard
  • git clean -fd
  • git push --force

Instalação (altera lockfiles):

  • npm install
  • pnpm install
  • yarn install
  • bun install
  • npm audit fix

Banco de Dados / Infraestrutura:

  • prisma migrate
  • prisma db push
  • supabase db push
  • docker compose down -v

Configuração:

  • Alterar arquivos .env
  • Modificar configuração global de ferramentas
  • Executar comandos de deploy/unpublish

Alterações em massa:

  • Formatação ampla (prettier/eslint --fix em todo o repositório)
  • Localizar e substituir em muitos arquivos sem revisão

Se não tiver certeza se um comando é seguro, pergunte antes de executar.

Erros Comuns

ErroRealidade
"A IA de fronteira disse, então deve estar certo"Planos de fronteira são hipóteses. Valide contra o repositório real.
"Vou verificar tudo no final"Erros se acumulam. Verifique cada etapa com a granularidade correta.
"Já li o plano, posso implementar tudo de uma vez"Implementação em lote = erros em lote + depuração mais difícil.
"Vou corrigir erros de lint pré-existentes enquanto estou aqui"Limpeza não relacionada mascara o que suas alterações realmente fizeram. Não faça.
"Esta etapa é simples, não preciso verificar git diff"Edições simples podem excluir código acidentalmente ou formatar arquivos não intencionados.
"Vou instalar a biblioteca ausente que o plano referencia"Pergunte primeiro. A biblioteca pode estar intencionalmente ausente ou não aprovada.
"npm run build é a única verificação que importa"Build é lento e amplo. Use lint/typecheck para etapas intermediárias.
"Se falhar, vou ajustar e re-executar até passar"Correções cegas sem novas informações são aleatórias. Re-leia os erros. Forme uma nova hipótese primeiro.
"O mesmo erro de novo, deixe-me tentar uma pequena alteração diferente"Mesmo erro + mesma estratégia = mesmo resultado. Mude a estratégia, não o patch.

Bandeiras Vermelhas — PARE e Re-avalie

  • "Vou verificar após a próxima etapa também" — Verifique AGORA.
  • "O plano de fronteira sabe mais que o repositório" — O repositório é a fonte da verdade.
  • "Esta biblioteca não está instalada mas o plano precisa dela" — Pergunte ao usuário. Não instale silenciosamente.
  • "O diff é maior que o esperado, mas provavelmente está tudo bem" — Inspecione e explique antes de continuar.
  • "Vou agrupar as etapas 2 e 3 já que são relacionadas" — Uma etapa = um ciclo de verificação + diff.
  • "Erros de lint pré-existentes, deixe-me corrigi-los primeiro" — Não é seu trabalho. Registre-os. Mantenha o foco.
  • "Deixe-me formatar este arquivo enquanto o edito" — Alteração separada = etapa separada. Não misture.
  • "Ainda falhando, deixe-me tentar outra correção rápida" — Pare de corrigir. Re-leia o erro. Forme uma nova hipótese primeiro.
  • "O mesmo erro 3 vezes, mais um ajuste pode funcionar" — Mesmo erro + mesma estratégia = aleatório. Mude a estratégia ou relate o bloqueador.
  • "Vou apenas reescrever tudo e ver se isso corrige" — Jogar fora o trabalho sem entender por que falhou não ensina nada. Diagnostique primeiro.
  • "O usuário está com pressa, vou pular a verificação do diff" — 5 segundos de git diff --stat previnem horas de depuração.

Referência Rápida

FaseAçãoFerramenta
Pré-voogit status, detectar comandos, verificação de linha de baseBash
Analisar + Verificação de RealidadeLer plano, validar cada etapa contra o repositórioRead + Glob
RastrearCriar todowrite ou checklist markdowntodowrite / markdown
ImplementarLer arquivos de destino, fazer a menor alteração coerenteEdit / Write
VerificarExecutar verificação mais restritaBash
Inspecionar Diffgit diff --stat, git diff, verificar escopoBash
ConfirmarMarcar concluído, resumir, passar para próxima etapatodowrite / markdown
FinalVerificação forte + relatório com adaptações e falhasBash

Comportamento do Agente

  • Nunca se apresse. A etapa mais rápida que você pode pular é a que causa um erro que leva horas para depurar.
  • Nunca esconda incerteza. Se não tiver certeza sobre um caminho de arquivo, função, padrão ou dependência, verifique primeiro.
  • Nunca assuma que o plano está correto sobre a estrutura do repositório. O repositório é a verdade.
  • Nunca faça o usuário se sentir mal por fornecer um plano imperfeito. Adapte-se, documente, prossiga.
  • Sempre explique as adaptações. Se o plano disse X mas você fez Y, documente o desvio e o motivo.
  • Sempre mantenha a intenção do plano. Você pode alterar a implementação, mas não o resultado esperado.
  • Sempre verifique cada etapa com a ferramenta certa. Teste unitário para lógica, integração para API, typecheck para interfaces.
  • Sempre relate bloqueadores de forma estruturada, com comando, arquivo, hipótese, estratégias tentadas e próxima ação provável.

Individual skills in this repo

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

ASoudy/AGS

Advanced JavaScript animation library skill for creating complex, high-performance web animations.

ASoudy/AGS

Astropy is the core Python package for astronomy, providing essential functionality for astronomical research and data analysis.

ASoudy/AGS

Build content-focused websites with Astro — zero JS by default, islands architecture, multi-framework components, and Markdown/MDX support.

ASoudy/AGS

One sentence - what this skill does and when to invoke it

ASoudy/AGS

Audit and fix animation performance issues including layout thrashing, compositor properties, scroll-linked motion, and blur effects. Use when animations stutter, transitions jank, or reviewing CSS/JS animation performance.

ASoudy/AGS

Internationalization and localization patterns. Detecting hardcoded strings, managing translations, locale files, RTL support.

ASoudy/AGS

Pull a YouTube video transcript into a queryable markdown vault with yt-dlp subtitle discovery, VTT cleanup, metadata frontmatter, and capture-seed stubs.

ASoudy/AGS

Expert in building portfolios that actually land jobs and clients - not just showing work, but creating memorable experiences. Covers developer portfolios, designer portfolios, creative portfolios, and portfolios that convert visitors into opportunities.

ASoudy/AGS

Generates high-converting Next.js/React landing pages with Tailwind CSS. Uses PAS, AIDA, and BAB frameworks for optimized copy/components (Heroes, Features, Pricing). Focuses on Core Web Vitals/SEO.

ASoudy/AGS

AI-powered animation tool for creating motion in logos, UI, icons, and social media assets.

ASoudy/AGS

CRITICAL: Use for Makepad animation system. Triggers on: makepad animation, makepad animator, makepad hover, makepad state, makepad transition, "from: { all: Forward", makepad pressed, makepad 动画, makepad 状态, makepad 过渡, makepad 悬停效果

ASoudy/AGS

Comprehensive patterns for Next.js 14+ App Router architecture, Server Components, and modern full-stack React development.

ASoudy/AGS

Next.js App Router principles. Server Components, data fetching, routing patterns.

ASoudy/AGS

Expert integration of Supabase Auth with Next.js App Router

ASoudy/AGS

React and Next.js 14+ application development with App Router, Server Components, TypeScript, Tailwind CSS, and modern frontend patterns.

ASoudy/AGS

Best practices for Remotion - Video creation in React

ASoudy/AGS

Generate walkthrough videos from Stitch projects using Remotion with smooth transitions, zooming, and text overlays

ASoudy/AGS

Seek and analyze video content using Memories.ai Large Visual Memory Model for persistent video intelligence

ASoudy/AGS

Writes complete, structured landing pages optimized for SEO ranking, AEO citation, and visitor conversion. Activate when the user wants to write or generate a landing page for a product, service, or offer.

ASoudy/AGS

Skill for discovering and researching autonomous AI agents, tools, and ecosystems using the AgentFolio directory.

Habilidades Relacionadas