Padrões de engenharia que o agente segue — não negocia.
Pacotes de skills normativas para Claude Code. Pisos inegociáveis de arquitetura, segurança e teste — um piso comum para todo código, humano ou IA. Instale com um comando; funciona em Claude Code, Claude.ai e na API.
$ curl -fsSL https://github.com/schematizeme/schematize-cli/releases/latest/download/install.sh | bash$ schematize install --allUma CLI para todo o catálogo.
O schematize é uma CLI em Rust — com app de desktop incluso — que instala e versiona todas as skills a partir de um índice remoto ao vivo. Skill nova aparece sem reinstalar nada.
- Instala e versiona skills — a partir de um catálogo remoto; um comando puxa tudo e mantém atualizado.
- App de desktop incluso — uma janela para navegar, instalar e atualizar skills — vem pronto, sem ferramentas de build.
- doctor · upgrade · status — diagnostica seu ambiente, se autoatualiza e mostra tudo num painel.
- Agente residente — vigia novas versões de skills e posts do blog e te notifica nativamente.
Baixe o app
Instale o schematize no macOS, Linux ou Windows — o app de desktop vem junto.
v0.8.1 · github.com/schematizeme/schematize-cli
Baixe o app, extraia e botão-direito → Abrir (Apple Silicon; tem build Intel na página do release).
schematize-macos-arm64-app.zip- unzip → Ctrl-click → Open
Debian, Ubuntu e Linux Mint. Um comando instala o .deb (CLI + app de desktop) e resolve as libs da GUI.
Num terminal:
$ curl -fsSL https://github.com/schematizeme/schematize-cli/releases/latest/download/install.sh | bashopenSUSE, Fedora e RHEL. Um comando instala o .rpm (CLI + app de desktop).
Num terminal:
$ curl -fsSL https://github.com/schematizeme/schematize-cli/releases/latest/download/install.sh | bashBaixe o zip, extraia e rode schematize-gui.exe. Ponha schematize.exe no PATH pro CLI.
schematize-windows-x86_64.zip- extract → run
schematize-gui.exe
O app do macOS e o .exe do Windows ainda não são assinados — o sistema mostra um aviso único de “não verificado” no primeiro uso (macOS: botão-direito → Abrir; Windows: Mais informações → Executar assim mesmo).
Não quer instalar?
Leia as normativas completas e copie direto pro seu projeto — ou instale a skill para o agente aplicar sozinho.
Pacotes
Cada pacote é uma skill no padrão aberto Agent Skills, versionada e servida via CDN.
schematize-go
Padrões de engenharia backend Go/Rust: segurança server-side, testes que provam, índice como fonte da verdade e archive obrigatório.
schematize-web
Padrões de frontend Next.js/Astro: segredo só no servidor, acessibilidade WCAG 2.2 AA, Core Web Vitals como contrato, SEO + dados estruturados e i18n. A irmã de frontend do schematize-go.
schematize-rust
Padrões normativos de engenharia para backends com Rust como linguagem principal (Go auxiliar).
schematize-node
Padrões normativos para manter código legado Node.js/TypeScript e migrar para Go/Rust — sem backend novo em Node.
schematize-engineering
A base comum de engenharia (agnóstica de linguagem): arquitetura/DDD, MAPA+grafo+endpoints, segurança, dados, observabilidade, entrega/DoD/archive e orquestração (dividir em mini-tasks + paralelizar com subagents — tempo sobre tokens). As skills de linguagem a especializam.
schematize-pentest
Teste de segurança: AppSec defensivo (rejeição rota-por-rota, IDOR/BOLA, BFLA, injeção, SSRF, JWT/OAuth) e red-team autorizado (cadeias de ataque concretas, ATT&CK). Arsenal por classe + cobertura OWASP Web/API Top 10 + threat modeling STRIDE + matriz de autorização — sempre sob autorização + escopo + RoE.
schematize-seo
Padrões normativos de SEO da casa: técnico, on-page, conteúdo/keywords, dados estruturados, internacional/multi-domínio (sem canibalizar), AIO/LLMO/GEO, autoridade/E-E-A-T e medição.
schematize-elixir
Padrões normativos de engenharia para backends em Elixir — Phoenix/Ecto/OTP sobre a BEAM, realtime e alta concorrência tolerante a falha.
schematize-csharp
Padrões normativos de engenharia para backends em C# / .NET (ASP.NET Core, EF Core).
schematize-zig
Padrões normativos de engenharia para sistemas em Zig — baixo nível, performance e controle manual de memória.
schematize-ruby
Padrões normativos de engenharia para backends, serviços e scripts em Ruby (Rails/Sinatra).
schematize-audit
Auditoria de histórico da casa: enumera e CONTA todos os checklists criados (overdev, Q.A., handoffs, planos, ADRs, perguntas parkeadas, premature-stops) e prova que cada item foi SANADO — acha órfãos RED, reabre 'feito' sem prova, gera checklist de saneamento e trava o veredito se sobrar órfão.
schematize-ai
Engenharia de sistemas com IA/LLM da casa: provider-agnóstico (Claude default, plugável), prompt & context engineering, RAG (chunking/embeddings/retrieval/avaliação), agents & tool-use (loop/function-calling/MCP), evals & guardrails (red-team, jailbreak, PII, saída estruturada validada, deny-by-default), custo/caching e observabilidade de LLM. Pisos: nenhum LLM decide autorização, toda saída de IA é não confiável até validada, prompt injection é ataque de 1ª linha, segredo nunca no prompt/cliente, RAG isolado por tenant.
schematize-data
Engenharia de dados da casa: trata o dado como CONTRATO — schema versionado com compatibilidade (back/forward/full), pipelines ETL/ELT batch e streaming, event sourcing/CDC via Outbox (dual-write vetado), qualidade com quarentena e dead-letter (dado ruim não contamina o downstream), lineage & catálogo, migrations expand-contract reversíveis, idempotência/replay e governança de PII (deny-by-default, base legal + retenção, LGPD).
schematize-mobile
Engenharia de apps mobile da casa: o mesmo piso (segurança, IAM, testes, ops, DoD, archive) no cliente hostil que é o dispositivo — escolha de plataforma nativo (Swift/Kotlin) vs cross (KMP/Flutter/RN) por fit + ADR; offline-first & sync (outbox durável, idempotência, delta sync, conflito explícito, servidor autoritativo); IAM mobile casado com o iam.md (OIDC/PKCE delegando ao auth.<domain>, passkeys+biometria, secure storage, logout irreversível, NUNCA segredo no bundle, authz no servidor); push (APNs/FCM), performance/bateria/rede, entrega nas lojas (assinatura, staged rollout, OTA nas regras, review), observabilidade/crash e segurança (SPKI pinning, root/jailbreak como sinal, ofuscação sensata).
schematize-infra
Infra/DevOps/SRE da casa: opera sistema em produção com blast radius mínimo — isolamento por app (user Linux + systemd hardened + container por serviço), IaC declarativa/idempotente/revisável, deploy GATED (nada pula etapa; front manual/gated), segredo nunca no repo (cofre + rotação), observabilidade integrada (SLO/alertas), backup & DR com RESTORE testado, redes/TLS/hardening deny-by-default e supply-chain (SBOM/pinning/assinatura). Deny-by-default, least-privilege, tudo auditado.
schematize-docs
Documentação da casa como disciplina: doc é parte da Definition of Done (não opcional), docs-as-code (no repo, revisada, versionada, TESTADA), ADR pra toda decisão relevante (proposed → accepted/rejected), runbooks operacionais, API docs/OpenAPI gerada do código, changelog + SemVer, diagramas C4/mermaid, e o índice/archive que a auditoria consome.
schematize-scaffold
O scaffolder da casa: o blueprint executável de 'projeto novo da casa', lastro do `schematize new <projeto>`. Cria um projeto que já NASCE com o piso do dia 0 — repos por contexto (`<projeto>_<ctx>_<lang>`), IAM como app separada (`<projeto>_auth_<lang>` + `authfront`, delegação OIDC), front separado, `<projeto>_ops` com isolamento por app, CI com deploy gated, testes/pentest, DoD, archive/índice e overdev; linguagem por fit + ADR. Traz o scaffold-new (criar) e o scaffold-check (auditar o piso de um projeto existente). Nada de projeto sem IAM/sem ops 'pra depois' — o piso é dia 0.
Como funciona
O app lê um índice ao vivo (catalog.json) no GitHub, então publicar uma skill nova é só adicionar uma entrada — sem recompilar a CLI.
1 · instale o app
Um comando instala a CLI schematize e o app de desktop no Linux (.deb / .rpm / binário).
2 · instale as skills
Rode schematize install --all para puxar todas as skills pro .claude/, ou instale uma pelo slug.
3 · mantenha atualizado
O agente residente avisa quando uma skill ou o app tem update; schematize upgrade se autoatualiza.