Communitygithub.com

lguidolin/merge-gates-and-automation

Use ao configurar ou alterar CI, hooks de pre-push ou um executor de tarefas, ou ao decidir o que deve ser aprovado antes de um merge. Sintomas — tentação de colocar verificações autoritativas apenas em um hook local, pular CI, ignorar com `--no-verify` ou incerteza sobre o que bloqueia um merge versus o que é executado localmente.

O que é merge-gates-and-automation?

Esta skill define uma arquitetura clara para gates de verificação e automação, estabelecendo que a CI é a fonte da verdade, enquanto o hook local é apenas um espelho de conveniência e explicitamente contornável. Ela descreve por que regras não aplicadas por gates incontornáveis são apenas sugestões (Princípio 7) e como declarar modos `enforced` (CI bloqueia merge via proteção de branch) ou `advisory` (CI executa e relata, mas a disciplina é o gate). A skill lista regras práticas para canonicidade do executor de tarefas, hierarquização de CI (presubmit/postsubmit), construção de imagens de contêiner em CI com digest de conteúdo e atestado de proveniência, além de racionalizações comuns e bandeiras vermelhas. Ela atende equipes de engenharia que usam GitHub Actions, GitLab CI, ou sistemas similares, e que precisam de diretrizes formais para evitar que verificações escapem para hooks contornáveis ou builds locais sem proveniência verificável.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/lguidolin/agent-skills/tree/main/skills/merge-gates-and-automation

Perguntar na sua IA favorita

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

Documentação

Gate de Verificação e Automação

Visão Geral

Onde a verificação reside e o que a torna real. A CI é a fonte da verdade; o hook local é um espelho de conveniência. Uma regra não aplicada por um gate incontornável é uma sugestão (Princípio 7) — portanto, onde a plataforma não pode fornecer esse gate, o projeto declara modo advisory e carrega a regra deliberadamente, em vez de assumir mecanismos que não possui.

As Regras

  • Um executor de tarefas é a entrada canônica para toda operação do dia a dia — test, build, dev, deploy são receitas nomeadas. Um procedimento que existe apenas na cabeça de alguém não acontece de forma confiável e não pode ser passado para um agente.
  • A CI é a fonte da verdade — autoritativa, compartilhada e incontornável sempre que a plataforma permitir. Lint, typecheck, verificações de contrato, testes, varreduras de segurança, validação de commits — tudo é executado aqui e deve ser aprovado antes do merge no modo enforced. O que a CI diz é o que conta. No modo advisory, as mesmas verificações rodam e relatam; o gate é a disciplina, e isso nunca é motivo para executar menos verificações.
  • O hook de pre-push é um espelho de pré-submissão, não uma muralha. Ele executa as mesmas verificações rápidas localmente para que você provavelmente passe na CI antes de enviar. Ele é explicitamente contornável (--no-verify) e só é executado onde o toolchain está instalado. Seu trabalho é velocidade e feedback rápido, não aplicação. O hook nunca bloqueia; a CI bloqueia sempre que a plataforma permitir.
  • Mantenha a CI rápida hierarquizando, não removendo verificações. Quando o conjunto completo excede a capacidade de todo PR, divida em presubmit (subconjunto rápido, bloqueia o PR) e postsubmit (conjunto completo, após o merge, bloqueia a promoção) — nunca mova verificações autoritativas de volta para o hook contornável.
  • Imagens de contêiner são construídas na CI, identificadas pelo digest de conteúdo e publicadas com uma atestação de proveniência. Mantenha o custo acessível com cache de camadas do registry ou um runner auto-hospedado — nunca movendo a construção para um laptop, onde a proveniência do artefato não pode ser verificada por ninguém mais.
  • Declare o modo de aplicação. enforced — CI bloqueia merge via proteção de branch; o que a CI diz é o que conta. advisory — CI executa e relata, e o gate é a disciplina, porque a proteção de branch não está disponível (um repositório privado em um plano gratuito). Advisory é legítimo; alegar aplicação que você não tem não é. Indique o modo no primeiro registro de decisão do projeto e o que o moveria para enforced.

A Tensão Nomeada

Um presubmit local contornável é rápido mas inaplicável; a CI autoritativa é aplicável mas mais lenta. Resolva dando a cada um um mandato diferente — o hook otimiza o loop interno, a CI a correção do registro — e tornando a CI, não o hook, o que bloqueia um merge.

Racionalizações Comuns

DesculpaRealidade
"O hook de pre-push executa os testes, então a CI pode ser mínima"O hook é contornável e depende de toolchain. Não pode ser a fonte da verdade. A CI deve reexecutar tudo.
"Só vou usar --no-verify desta vez"Tudo bem — porque a CI ainda pegará. É exatamente por isso que a CI, não o hook, é o gate.
"A CI está lenta, vamos mover os testes para o hook"Hierarquize a CI (presubmit/postsubmit); nunca realoque verificações autoritativas para um gate contornável.
"As builds da CI são lentas, vou construir a imagem localmente"Um artefato construído em laptop carrega proveniência que ninguém mais pode verificar. Corrija a latência com cache de camadas ou runner auto-hospedado.
"A proteção de branch custa dinheiro, então as regras não se aplicam"As regras se aplicam; a aplicação difere. Declare modo advisory e mantenha a disciplina, ou torne o repositório público e obtenha proteção gratuita.

Bandeiras Vermelhas — PARE

  • Verificações autoritativas que existem apenas em um hook local
  • CI que não reexecuta o que o hook executou
  • Um merge permitido enquanto a CI está vermelha
  • Uma imagem construída em qualquer lugar exceto na CI, ou promovida por tag em vez de por digest
  • Um projeto se comportando como se a CI bloqueasse o merge quando não existe proteção de branch

Raciocínio completo: Artigo VIII da constituição, empacotado em engineering-constitution/references/engineering-constitution.md. Detalhes de deploy/k8s: cloud-delivery-aks.

Individual skills in this repo

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

lguidolin/change-hygiene-and-code-craft

Use when writing or refactoring code, structuring a commit or PR, or deciding whether to abstract duplication. Symptoms — mixing reorg with logic changes, a PR doing several things at once, a file growing large, the second copy of similar code, or unsure whether to DRY something up.

lguidolin/cloud-delivery-aks

Use when deploying to Kubernetes or Azure Kubernetes Service (AKS), configuring cloud secrets, setting up progressive rollout/canary, per-PR ephemeral environments, or k8s health probes. Keywords — Kubernetes, AKS, Key Vault, Argo Rollouts, Flagger, canary, blue-green, liveness, readiness, PodDisruptionBudget, HPA, rollback, GHCR.

lguidolin/commit-history-rewrite

Use when an existing repository has messy commit history that needs to conform to conventional commits before adopting release-please, or when intermediate WIP/fixup/merge commits need to be cleaned up.

lguidolin/conventional-commits-and-releases

Use when committing, writing a commit message, opening a PR that will be squash-merged, or configuring automated versioning/changelogs. Keywords — conventional commits, release-please, semver, feat/fix/chore, breaking change, changelog.

lguidolin/defense-in-depth-security

Use when handling untrusted input, secrets, authentication/authorization, or dependencies — or threat-modeling a new surface. Keywords — STRIDE, threat model, least privilege, secrets management, supply chain, dependency scanning, input validation, audit log, defense in depth.

lguidolin/designing-before-building

Use when starting a feature, fixing a non-trivial bug, or about to write implementation code — before any code exists. Symptoms you need this: "this is simple, I'll just code it", reaching for the editor before a design is approved, or an idea that hasn't been turned into a spec and plan.

lguidolin/engineering-constitution

Use when starting work in a project that follows the engineering constitution, orienting to its rules, or deciding which engineering practice applies to a task — spec writing, commits, testing, security, deploys, database, or UI work.

lguidolin/graphql-contract-testing

Use when writing a GraphQL query/mutation that the UI and a test will share, or building route/schema contract or smoke tests. Symptoms — copying a query into a test, a test asserting on query text, schema change that didn't break the UI build, or RLS/permission drift. Keywords — graphql-codegen, typed document, contract test, route smoke test.

lguidolin/init-repo-CI

Use when setting up a new repository with conventional commits, release-please, and CI automation, or when retrofitting an existing repository that lacks automated versioning and PR validation workflows.

lguidolin/interface-craft-and-accessibility

Use when building or styling UI — components, layouts, forms, design tokens — or making accessibility decisions. Keywords — a11y, WCAG, keyboard navigation, focus state, contrast, design system, minimalist UI, component reuse, ARIA, semantic HTML.

lguidolin/observability-and-slos

Use when adding logging, metrics, tracing, health checks, SLOs, or alerting — or when building a service surface that needs to be operable and debuggable. Keywords — structured logs, OpenTelemetry, correlation id, RED metrics, liveness, readiness, SLI, SLO, error budget, alerting.

lguidolin/performance-and-scale

Use when working on hot paths, list endpoints, pagination, data-access in loops, or public interfaces/schemas. Symptoms — unbounded queries, N+1 access, no latency budget, optimizing without measuring, or changing an interface many consumers depend on. Keywords — pagination, N+1, Hyrum's Law, performance budget, bundle size.

lguidolin/postgres-postgraphile-rls-and-sql

Use when writing PostgreSQL, PostGraphile config, Row-Level Security policies, SQL schema files, or working on the Browser→App→PostGraphile→Postgres data path. Keywords — RLS, SECURITY DEFINER, search_path, pgSettings, grants, roles, GraphQL depth limit, query cost, statement_timeout, SQL file organization.

lguidolin/recording-decisions

Use when a design or architecture decision has been made and needs to be captured — writing a decision record or ADR, updating a decision index, noting a deferred idea, or superseding a past decision. Keywords — ADR, decision record, rationale, rejected alternatives, dependency index.

lguidolin/resilience-and-deploy-safety

Use when planning a deploy, designing a rollback, or responding to an incident or writing a postmortem. Keywords — deploy safety, rollback, immutable artifact, progressive delivery, canary, blast radius, incident response, blameless postmortem, error budget.

lguidolin/ship-it

Use when the user wants to ship work — push, PR, archive decision records, merge, and clean up. Handles the full lifecycle from committing final changes through post-merge cleanup including converting specs/plans to compact decision records.

lguidolin/tests-as-a-control

Use when writing or modifying tests, when a test breaks during a refactor, or when testing permission/role rules. Symptoms — tempted to edit a test to make it pass, testing only the happy path, a deny-test that started passing, flaky tests, or unsure what to assert.

lguidolin/zero-downtime-migrations

Use when changing a database schema where data must survive the change — adding/removing/renaming columns, constraints, indexes, or backfilling. Symptoms — a destructive migration bundled with a code deploy, a NOT NULL column with a backfill, a table-locking UPDATE, or a rename. Keywords — expand/contract, parallel change, backfill, NOT VALID, CREATE INDEX CONCURRENTLY, graphile-migrate.

Habilidades Relacionadas