Higher Mind Code Skills
rodrigohighermind/highermind-code-skills
Doze modos cognitivos que codificam seus padrões de qualidade
Ver no GitHubConjunto de 12 modos cognitivos para Claude Code que codificam padrões de qualidade world-class. Inclui skills para engenharia, segurança, design, performance e deploy — elimina a necessidade de repetir instruções sobre padrão de qualidade a cada sessão.
Instalação
npx convez-ai rodrigohighermind/highermind-code-skills1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Garantir padrão production-grade em todo código desde o início
- Auditar segurança em múltiplas camadas (OWASP, ASVS, supply chain)
- Validar arquitetura, performance e integridade de dados antes de deploy
- Implementar guardrails para aplicações com LLM
- Orquestrar validação completa pré-ship de projetos
Veredito

Abordagem sólida para codificar padrões de qualidade em workflows com IA. Reduz fricção ao eliminar repetição, mas requer disciplina para manter CLAUDE.md atualizado e bem definido. Melhor aproveitado por engenheiros sênior com padrões já consolidados.
README
A tradução para o português deste README ainda está na fila.
highermind-code-skills
Antes de existir uma empresa, existiu uma mente que decidiu construir.
Doze modos cognitivos de execução para o Claude Code. Construído em cima da filosofia Higher Mind: empresas são extensões da arquitetura interna do fundador. Se o código é mediano, o padrão era mediano. Se o software é world-class, a mente por trás dele exigiu world-class.
Skills de direção estratégica (/hm-align, /hm-sequoia) estão em highermind-business-skills.
Isso não é um pack de prompts. É um padrão, codificado uma vez, pra você nunca mais ter que se repetir.
O problema
Toda vez que você abre o Claude Code, você começa do zero. O agente não sabe qual é a sua barra. Não sabe que "bom o suficiente" não é suficiente. Não sabe que você pensa em décadas, não em sprints. Então você se repete:
- "Faz world-class."
- "Checa segurança. Todas as camadas."
- "O design precisa ser nível Apple."
- "Roda testes. Cobre tudo." Você fala as mesmas coisas, com palavras diferentes, toda vez. A qualidade do output depende de quão bem você traduz o seu padrão naquele momento específico.
highermind-code-skills resolve isso. Você traduz o seu padrão uma vez. Depois ele está sempre lá.
Como funciona
Duas camadas:
CLAUDE.md — sua identidade. Sempre ativo. Todo projeto, toda sessão. O agente sabe quem você é, qual é a sua barra, e que mediocridade não é opção. Você nunca mais precisa explicar isso.
Skills — modos cognitivos que você ativa quando precisa. Cada um coloca o agente num mindset específico com um trabalho específico.
| Skill | Quando | O que faz |
|---|---|---|
/hm-init | Início de projeto | Melhores ferramentas, melhor estrutura, melhores práticas. World-class desde o primeiro arquivo. |
/hm-engineer | Validar código | Arquitetura, segurança, performance, custo, qualidade. Todas as camadas. Production-grade. LLM patterns nativos. |
/hm-security | Auditoria de segurança | OWASP Top 10, ASVS L1/L2/L3, secrets, supply chain, LLM gotchas, multi-tenant, file upload, business logic. Padrão Tempest/Trail of Bits. |
/hm-designer | Validar interface | Pra onde o software está indo, não pra onde ele esteve. Sofisticação, encantamento, beleza. Padrão Linear/Stripe/A24. |
/hm-ux-flow | Validar fluxo | Não substitui designer (visual). Foca em DECISÃO do user. Friction points, hierarquia, recovery. |
/hm-qa | Testar tudo | Roda, quebra, verifica que funciona. Edge cases, fluxos, agente, infra, uso real. Checklist de bugs recorrentes. |
/hm-performance | Performance profiling | Bundle, render, API latency, DB, LLM tokens, network, memory. Numbers concretos com fix por gargalo. |
/hm-data-integrity | Dados sagrados | Backup, migration safety, destrutivas, runtime integrity, DR plan, compliance, file integrity. |
/hm-llm-guardrails | App com LLM | 12 patterns obrigatórios: sliding window, lazy client, in-flight dedupe, streaming abort, schema validation, cross-channel safety, cost tracking. |
/hm-deploy | Validar deploy | Multi-modelo: Container, Serverless, Desktop (Electron), Mobile (Expo), Library, CLI. Reprodutibilidade, segurança, dados. |
/hm-validate-all | Pré-ship completo | Orquestrador: dispara as 5 (security/engineer/qa/designer/deploy) em ordem otimizada, consolida findings priorizados. |
/hm-cli | Construção de CLI | Bun + Ink + bun:sqlite, agentic-first, cinematográfico. Stack obrigatória, 4 camadas de resposta (slash → regex → Sonnet → tool), custo por turn auditado, dados sagrados, learning persistente. |
Skills de direção (
/hm-align,/hm-sequoia) estão em highermind-business-skills.
O fluxo
/hm-init você começa um projeto novo. ele nasce certo.
/hm-cli se o produto é CLI: Bun + Ink + agentic-first.
[constrói] você dirige, o agente executa.
/hm-designer interface na barra.
/hm-ux-flow fluxo na barra.
/hm-engineer código na barra (com LLM patterns).
/hm-llm-guardrails se app integra Claude/GPT/Gemini.
/hm-performance latência/custo/bundle dentro do alvo.
/hm-data-integrity dados protegidos. backup testado.
/hm-security auditoria de segurança L1/L2/L3.
/hm-qa funciona end-to-end. edge cases cobertos.
/hm-deploy sobe, roda, reproduz. multi-modelo.
/hm-validate-all orquestra as 5 principais. report único.
Você não precisa usar todas toda vez. Use o que o momento pede. /hm-validate-all é o atalho pré-ship que dispara as 5 essenciais (security/engineer/qa/designer/deploy) e consolida.
Pra validar direção e estratégia, use as business skills:
/hm-align(é a coisa certa?) e/hm-sequoia(está indo pro futuro?).
Demo
Você: Preciso construir o fluxo de aplicação pra uma comunidade de founders.
Membros aplicam, são avaliados, aceitos ou colocados em waitlist.
Você: /hm-init
Claude: [Seleciona Next.js 15, Tailwind, Supabase, Resend pra emails.
Estrutura monorepo. Configura auth, schema do banco, rotas de API,
framework de testes. Tudo organizado, production-grade
desde o primeiro commit.]
Você: Constrói o fluxo de aplicação.
Claude: [Implementa: formulário multi-step, fila de revisão, motor de
decisão, notificações por email, tracking de status, lógica
de reaplicação.]
Você: /hm-designer
Claude: O formulário usa layout padrão com cards e bordas cinza.
Isso é software de 2020. Problemas:
- Sem hierarquia visual. Toda pergunta tem o mesmo peso.
- Tipografia padrão. Sem intenção editorial.
- Fundo claro, sem dark mode.
- Parece um onboarding de SaaS, não um gateway.
Correção: uma pergunta por tela, interface dark, transições
cinematográficas, tipografia editorial. A aplicação deve parecer
uma experiência, não um formulário.
Você: /hm-engineer
Claude: [CRÍTICO] Race condition: revisores concorrentes podem aceitar
o mesmo aplicante, disparando emails de boas-vindas duplicados.
Fix: optimistic locking no status de revisão.
[CRÍTICO] Sem rate limiting no endpoint de aplicação.
Fix: middleware de rate limiter, 3 submissões por email por dia.
[ALTO] Fila de revisão expõe emails dos aplicantes pra todos
os revisores sem controle de acesso por role.
Fix: mascarar emails, adicionar modelo de permissão por revisor.
Arquitetura sólida. Data flow limpo.
3 findings. Corrigir os críticos antes de shippar.
Você: [corrige tudo]
Você: /hm-qa
Claude: [Roda suite de testes completa. Navega fluxo de aplicação end to end.
Testa: submissão, submissão duplicada, campos vazios, aceitar,
rejeitar, waitlist, reaplicação, revisões concorrentes,
entrega de email, viewport mobile.]
12/12 cenários passaram. Fluxo de aplicação funciona end to end.
Um issue menor: tela de sucesso não renderiza corretamente
em viewports abaixo de 375px. Não bloqueia.
Pra quem é isso
Você constrói porque não consegue não construir. Você usa Claude Code como seu time de dev. Você sabe exatamente como é world-class, mas está cansado de traduzir esse padrão em palavras toda sessão.
Isso codifica o seu padrão uma vez. O agente opera no seu nível desde o primeiro comando.
/hm-init
Início de projeto.
Você abre um projeto novo. Digita /hm-init e descreve o que quer construir. O agente não faz só scaffold. Ele toma decisões:
- O melhor framework pra esse tipo de projeto (com framework de decisão ponderado)
- O melhor banco de dados, ORM, solução de auth
- A melhor estrutura de pastas e patterns de arquitetura
- Agent-first como default arquitetural (quando aplicável)
- Infraestrutura local com Docker Compose desde o dia 1
- Restrições de custo como parte do design
- Setup de testes desde o dia um
- Gerenciamento de environments
- Formatação e linting do código
Cada escolha é justificada contra critérios explícitos: fit pro problema, performance, custo em produção, maturidade, ecossistema, DX. Nada é padrão. Nada é "a gente geralmente usa isso."
O padrão: se um time de engenharia world-class olhasse pra esse projeto no dia um, diria "é assim que se começa um projeto."
/hm-engineer
Validar código.
Você digita /hm-engineer e o agente audita tudo. Não é lint. Não é estilo. É estrutura, segurança, custo e resiliência.
Começa com um baseline inegociável de engenheiro senior (zero bare except, zero any types, zero fire-and-forget, zero secrets hardcoded). Depois audita:
- Arquitetura: responsabilidades, boundaries, data flow, agent loops
- Segurança: injection, auth bypass, secrets, trust boundaries, CSRF, ports expostos
- Performance: N+1 queries, indexes, re-renders, bundle size, caching, I/O paralelo
- Custo x Performance: API calls justificadas, contexto mínimo em LLMs, token usage consciente
- Dados sagrados: nenhuma operação destrutiva sem confirmação, volumes nomeados, migrations seguras
- Infraestrutura: Docker rebuild vs restart, health checks, ports, migrations
- Resiliência: tratamento de erros, retry logic, failure modes, race conditions
- Qualidade: testes significativos, naming, abstrações, dependências
- Escala: gargalos em 10x e 100x
O padrão: se você estivesse vendendo esse software e o comprador contratasse engenheiros pra auditar, eles não encontrariam nada pra reclamar.
/hm-designer
Validar interface.
Não é "faz bonito." É visão.
O design de software está se movendo. O que parecia moderno em 2020 parece datado agora. O que parece moderno agora vai parecer datado em 2028. /hm-designer não valida contra o padrão de hoje. Valida contra pra onde o software está indo.
A barra:
- Sofisticação: cada elemento tem uma razão pra existir. Nada decorativo. Nada de encher espaço.
- Diferenciação: essa interface só poderia pertencer a esse produto. Não é um template com conteúdo trocado.
- Experiência: usar esse software precisa parecer alguma coisa. Não neutro. Não invisível. Intencional.
- Encantamento: momentos que fazem a pessoa pausar e pensar "isso é lindamente feito."
- Usabilidade: sem esforço. O usuário nunca fica na dúvida do que fazer.
- Beleza: baseado nos produtos mais belos que a humanidade construiu. Apple. Airbnb. Linear. Stripe. Vercel.
O que é rejeitado:
- Qualquer coisa que parece que foi construída de um template
- Qualquer coisa que poderia pertencer a qualquer produto
- Qualquer coisa que usa light mode sem considerar dark mode
- Qualquer coisa com tipografia padrão, espaçamento padrão, tudo padrão
- Qualquer coisa que prioriza "shippar rápido" em vez de "shippar certo"
O padrão: mostre essa interface pra alguém com gosto. Não um designer. Alguém com gosto. Essa pessoa deve sentir que quem construiu isso se importa profundamente com o craft.
/hm-qa
Testar tudo.
Código que não é testado não existe. /hm-qa roda tudo:
- Testes unitários pra lógica de negócio
- Testes de integração pra endpoints de API e fluxos de dados
- Testes end-to-end pros fluxos críticos do usuário
- Testes de edge case (estados vazios, valores limites, operações concorrentes)
- Verificação de infraestrutura (containers sobem? migrations rodam? ports corretos? dados persistem?)
- Verificação de agente (tool loops terminam? não alucina tools? custo por interação?)
- Integridade de dados (persistência entre restarts, migrations não-destrutivas, backups)
- Check de custo (API calls por fluxo, contexto mínimo, custo por usuário/mês)
- Verificação em viewport mobile
- Testes de performance e acessibilidade básica
O agente não só roda testes. Ele pensa no que deveria ser testado e não está. Encontra os gaps.
O padrão: você deployaria isso com confiança numa sexta à noite.
/hm-deploy
Validar deploy e infraestrutura.
Você digita /hm-deploy e o agente valida que o projeto é reprodutível, seguro e pronto pra sair do local.
O que ele checa:
- Docker: containers sobem, ficam healthy, rebuild funciona, dados estão protegidos
- Environment: .env.example completo, nenhum secret exposto, ports documentados
- Database: migrations automáticas, schema consistente, dados persistentes
- Health: endpoints de health check, monitoramento de dependências
- Reprodutibilidade: clone limpo funciona com um comando
- Segurança: ports mínimos, CORS correto, secrets fora de logs
O teste definitivo: um engenheiro novo entra no time na segunda e tem o projeto rodando antes do almoço.
/hm-cli
Construção de CLI no padrão Higher Mind.
Terminal não é console. É cinema com restrição. Cada caractere existe por motivo, cada cor significa algo, cada espaço em branco foi escolhido. A barra: se a Linear, a Stripe, ou a A24 fizessem um CLI hoje, seria esse?
Você digita /hm-cli e o agente entra em modo CLI builder. Stack obrigatória:
- Bun (não Node) — single binary compile, startup instantâneo,
bun:sqlitenativo - TypeScript strict — zero
any, zerounknownsem narrow - Ink (React no terminal) — componentes compositáveis,
<Static>pra scrollback nativo, flexbox de verdade bun:sqlite(NUNCAbetter-sqlite3— não funciona em Bun)- Anthropic SDK — Sonnet 4.6 pra análise, Haiku 4.5 pra extração
bun build --compile— binário standalone ~60 MB, semnode, semnpm install- Install em
~/.local/bin/<name>(já no PATH em macOS/Linux, sem sudo)
Filosofia agentic-first: CLI HM é um agente operando num terminal, não um menu de comandos. Conversa é a interface primária. Slash commands existem pra atalhos rápidos, não pra obrigar o user a aprender sintaxe.
Arquitetura: 4 camadas de resposta, em ordem de custo. Slash command (zero token) → intent local regex (zero token) → Sonnet com contexto (~$0.003) → tool call (zero LLM). Regra de ouro: se a pergunta tem resposta em dado bruto local, camada 1-2 resolve. Sonnet só pra análise/insight.
Inclui patterns canônicos pra: blocks visuais (border + padEnd/padStart + bars + sparklines), CFO/banker tone PT-BR, learning persistente (source='manual' sobrescreve LLM), dados sagrados (idempotência + confirmação destrutiva), distribuição via release.
O padrão: se a Linear, a Stripe, ou a A24 fizessem um CLI hoje, seria esse.
Instalação
Requisitos: Claude Code, Git.
Passo 1: Instalar as skills
Abra o Claude Code e rode:
git clone https://github.com/rodrigohighermind/highermind-code-skills.git ~/.claude/skills/highermind-code-skills && cd ~/.claude/skills/highermind-code-skills && chmod +x setup && ./setup
Passo 2: Configurar o CLAUDE.md
Copie o template incluído pra ~/.claude/CLAUDE.md e customize:
cp ~/.claude/skills/highermind-code-skills/CLAUDE.md.template ~/.claude/CLAUDE.md
Edite ~/.claude/CLAUDE.md pra adicionar seu nome, seus projetos e suas especificidades.
O que é instalado
- Arquivos de skill em
~/.claude/skills/highermind-code-skills/ - Symlinks em
~/.claude/skills/hm-init,~/.claude/skills/hm-engineer,~/.claude/skills/hm-deploy, etc. CLAUDE.md.templatecomo ponto de partida pro seu arquivo de identidade global
Tudo fica dentro de ~/.claude/. Nada toca seu PATH ou roda em background.
Adicionar a um projeto (opcional)
Pra compartilhar as skills com o time num repo específico:
cp -Rf ~/.claude/skills/highermind-code-skills .claude/skills/highermind-code-skills && rm -rf .claude/skills/highermind-code-skills/.git && cd .claude/skills/highermind-code-skills && ./setup
Atualização
cd ~/.claude/skills/highermind-code-skills && git fetch origin && git reset --hard origin/main && chmod +x setup && ./setup
Desinstalação
for s in hm-init hm-engineer hm-security hm-designer hm-ux-flow hm-qa hm-performance hm-data-integrity hm-llm-guardrails hm-deploy hm-validate-all hm-cli; do rm -f ~/.claude/skills/$s; done && rm -rf ~/.claude/skills/highermind-code-skills
Filosofia
Construído em cima da filosofia Higher Mind:
Primeiro o fundador. Depois a empresa. Depois o mundo.
O mesmo vale pro software. Primeiro o padrão. Depois o código. Depois o produto. Se o padrão é world-class, tudo que vem depois também será.
Empresas são só o subproduto. Software é só o subproduto. O que importa é a mente que decidiu construir.
Licença
MIT
Mantido por @rodrigohighermind.