Os 8 Níveis de Maturidade em IA para Desenvolvedores

A Inteligência Artificial não vai substituir o desenvolvedor, mas o desenvolvedor que domina a IA certamente substituirá aquele que a ignora. Recentemente, um framework de 8 níveis de maturidade ganhou destaque na comunidade técnica, revelando que a produtividade real não vem da ferramenta que você usa (Cursor, Codex, Claude Code, Gemini CLI, etc), mas do seu modelo mental.

O segredo? A IA é um amplificador de conhecimento. Como diz o ditado: "Um dev ruim com IA apenas fará coisas ruins mais rápido; um dev bom será exponencialmente mais produtivo".

O Framework dos 8 Níveis

A jornada do uso de LLMs (Large Language Models) no desenvolvimento de software segue uma escala de complexidade, confiança e delegação de tarefas:

1. A Base: Do Nível 0 ao 2

Nestes estágios iniciais, a IA é vista apenas como um utilitário de consulta ou assistência visual.

• Nível 0 (Negacionista): Ignora a ferramenta, acreditando ser apenas um hype passageiro. Escreve tudo à mão.
• Nível 1 (Cauteloso): Usa o autocomplete básico na IDE. Aceita ou rejeita sugestões linha a linha.
• Nível 2 (Perguntador): Substitui o Stack Overflow pelo Chat. A IA responde dúvidas teóricas, mas o dev ainda implementa 100% do código.

2. O Grande Salto: Do Nível 3 ao 4

Aqui ocorre a transição mais crítica: deixar de microgerenciar código para especificar comportamento.

• Nível 3 (Delegador Básico): Pede funções isoladas, mas o processo é lento e exige muitos ajustes manuais ("copia e cola").
• Nível 4 (Diretor): Você para de pedir "faça essa função" e passa a fornecer contexto e especificações de alto nível.

No Nível 4, o fluxo de trabalho geralmente começa pela definição do comportamento (Test-Driven Development):

// Exemplo de fluxo no Nível 4:
// 1. O Desenvolvedor escreve o teste
test('deve validar CPF com máscara corretamente', () => {
expect(validarCPF('123.456.789-00')).toBe(true);
});

// 2. O Desenvolvedor pede para a IA:
// "Implemente a lógica que faça este teste passar no contexto do projeto X"

3. A Maestria: Do Nível 5 ao 7

Nesta fase, você opera como um gestor de agentes digitais e foca na engenharia de sistemas.

1. Nível 5 (Orquestrador): A IA usa ferramentas (como agentes) para navegar no projeto, ler arquivos e rodar testes de forma autônoma.
2. Nível 6 (Multiagente): Você gerencia múltiplos agentes trabalhando em paralelo em diferentes partes da aplicação.
3. Nível 7 (Arquiteto): O desenvolvedor define contratos de API e design de sistema. O código torna-se uma commodity gerada pelos agentes.

O Paradoxo da Skill: Por que o Hardness importa?

Existe um mito de que a IA facilitará a vida de quem não quer estudar. A realidade é o oposto: quanto mais alto o seu nível de uso de IA, mais conhecimento técnico (Hardness) você precisa.

Para ser um Arquiteto (Nível 7), você precisa dominar:

• Design Patterns e SOLID.
• Arquitetura de Software e Escalabilidade.
• Segurança e Performance de Código.

Sem essa base, você não consegue instruir ao agente de IA corretamente nem julgar se a solução proposta é sustentável a longo prazo. O uso contínuo do LLM cria um ciclo de aprendizado: seu conhecimento técnico guia o agente de IA, e o retorno deste expande sua capacidade de entrega.

Considerações finais: Qual o seu próximo passo?

Se você está estagnado no Nível 2 (tirando dúvidas no chat), seu desafio para esta semana é subir para o Nível 4. Comece a escrever especificações e testes antes de pedir o código. O agente de IA não é uma muleta; é um exoesqueleto. Ela aumenta sua força, mas quem decide a direção é você.

Feito!

O que são as AI Harness e por que elas mudam tudo

Se você já usou o Cursor, o Claude Code, o Codex, o Gemini CLI ou o novo GitHub Copilot e sentiu que a inteligência artificial estava "mágica", lendo seus arquivos e executando comandos como se fosse um humano, temos uma notícia para você: não é magia, é engenharia.

Recentemente, o termo "Harness" (ou arreio/suporte) tornou-se o novo hype do mundo tech. Mas o que isso realmente significa para o desenvolvedor comum e para o futuro dos sistemas autônomos? No presente artigo, vamos desmistificar como os agentes de IA realmente funcionam por "baixo do capô".

1. Desmistificando a "Harness"

Imagine a IA (um modelo como GPT-4 ou Claude ou qualquer outro LLM) como um cérebro superpotente, mas que vive numa redoma de vidro. Ele consegue pensar e falar, mas não tem braços nem pernas. A Harness é a estrutura de código que você constrói ao redor desse cérebro para dar-lhe ferramentas.

"O agente de IA não está dentro do seu computador. Ele é apenas um processador de texto que recebe e envia prompts. A Harness é o que transforma esse texto em ação real no seu disco rígido."

2. O Loop Infinito: Como a IA "age" de verdade

O segredo dos agentes de IA de sucesso não está apenas no modelo, mas no fluxo agêntico. Quando você pergunta algo à sua Harness, acontece um ciclo invisível em três etapas:

A. Envelopamento de Contexto

O sistema não manda apenas a sua pergunta. Ele envia um "manual de instruções" gigante (System Prompt) dizendo à IA exatamente quais ferramentas ela pode usar e como ela deve responder para ser entendida pelo código local.

B. A Chamada de Ferramenta (Tool Call)

A IA percebe que não tem a resposta no seu treinamento. Em vez de inventar, ela responde com um comando específico. Por exemplo:

{
  "action": "run_bash",
  "command": "ls -la ./src"
}

C. Execução Determinística

O código da Harness (escrito em linguagens como Python ou TypeScript) lê esse JSON, executa o comando de verdade no seu sistema operacional, captura a saída de texto e a envia de volta para a IA para que ela possa analisar os dados.

3. Da "Gambiarra" XML ao Function Calling Nativo

Nem sempre foi assim tão fluido. Antigamente, desenvolvedores precisavam "implorar" via prompt para que a IA respondesse em formatos específicos (como tags XML) para que o código conseguisse interpretar as intenções. Hoje, o Function Calling nativo permite que essa comunicação seja direta e precisa.

4. Por que você deve se importar?

Entender que a IA é baseada em código determinístico + prompts muda a forma como construímos software. Não se trata apenas de conversar com um robô, mas de criar sistemas que:

• Julgam a própria qualidade através de "Judge Models".
• Medem custos em tokens em tempo real.
• Decidem qual modelo (Haiku, Sonnet ou Opus) é melhor para cada tarefa.

Para aprender mais sobre como implementar essas ferramentas, confira o canal do Augusto Galego no YouTube, que inspirou esta análise.

Feito!

Como simular a visualização responsiva no celular com esta extensão no Chrome

Testar a responsividade de sites é essencial para desenvolvedores e designers. Em vez de alternar entre múltiplos dispositivos físicos, você pode usar uma extensão do Chrome para simular diferentes tamanhos de tela diretamente no navegador. Este guia mostra como instalar e usar a extensão Mobile simulator - responsive testing tool.

Passo 1: Acesse a página de extensões do Chrome

1. Abra o Google Chrome.
2. Clique nos três pontinhos verticais (⋮) no canto superior direito da barra de endereços.
3. No menu suspenso, selecione More tools → Extensions.
4. Alternativamente, digite chrome://extensions/ diretamente na barra de endereços e pressione Enter.

Passo 2: Abra a Chrome Web Store

Na página de extensões (chrome://extensions/), procure pelo menu de navegação no canto superior esquerdo (três linhas horizontais ou ☰) e clique nele. Em seguida, escolha a opção Open Chrome Web Store.

Você também pode acessar diretamente a loja através deste link: Chrome Web Store.

Passo 3: Procure pela extensão

Na Chrome Web Store, localize a barra de pesquisa no topo da página. Digite exatamente:

Mobile simulator - responsive testing tool

e pressione Enter. A extensão desejada aparecerá como o primeiro resultado da busca.

Passo 4: Instale a extensão

1. Clique no cartão ou título da extensão Mobile simulator - responsive testing tool para abrir sua página de detalhes.
2. Na página da extensão, clique no botão azul Add to Chrome.
3. Uma caixa de diálogo de confirmação aparecerá; clique em Add extension para concluir a instalação.

Após a instalação, o ícone da extensão (que se parece com um smartphone) será exibido ao lado da barra de endereços do Chrome.

Passo 5: Use o simulador para testar sites

1. Navegue até o site que você deseja testar pela responsividade.
2. Clique no ícone da extensão Mobile simulator - responsive testing tool na barra de ferramentas do Chrome.
3. Um painel será aberto com várias opções de dispositivos pré-definidos (como iPhone X, Pixel 2, iPad, etc.) e um campo para inserir dimensões personalizadas.
4. Selecione um dispositivo ou digite uma largura e altura específicas (em pixels).
5. A página será redimensionada automaticamente para simular a tela selecionada, permitindo que você visualize como o site aparece naquele formato.

Dicas para uso avançado

• Modo retrato/paisagem: Muitos simuladores incluem um botão de rotação para alternar entre orientações.
• Teste de múltiplos breakpoints: Mantenha o painel da extensão aberto enquanto desenvolve para alternar rapidamente entre tamanhos de tela.
• User-Agent personalizado: Para testes mais avançados, combine esta extensão com as ferramentas de modo de dispositivo do Chrome DevTools para modificar o User-Agent.
• Atalhos de teclado: Verifique se a extensão oferece atalhos para acelerar seu fluxo de trabalho (geralmente acessíveis em chrome://extensions/shortcuts).

Considerações finais

A extensão Mobile simulator - responsive testing tool oferece uma maneira rápida e eficiente de validar a responsividade de sites sem sair do Chrome. Ao seguir estes simples passos, você pode integrar testes de tela variados ao seu ciclo de desenvolvimento, economizando tempo e garantindo uma melhor experiência do usuário em todos os dispositivos. Experimente hoje mesmo e aprimore seu fluxo de trabalho de design e desenvolvimento web!

Link direto para a extensão (exemplo - verifique a ID atual na Chrome Web Store): Mobile simulator - responsive testing tool

Feito!

ISO 27001: O Padrão Ouro que separa Desenvolvedores Profissionais dos Amadores

Se você é desenvolvedor e ainda pensa que "segurança é problema do setor de TI", prepare-se: a ISO 27001 não é mais apenas um certificado para pendurar na parede – é o divisor de águas entre equipes que entregam software confiável e aquelas que estão um erro de distância do próximo vazamento catastrófico. E sim, isso afeta diretamente o seu código hoje.

Por que a ISO 27001 É o que diferencia "Funciona na Minha Máquina" de "Funciona no Mundo Real"

Vamos falar sério: a maioria dos desenvolvedores enxerga frameworks de segurança como burocracia que atrasa o delivery. Mas aqui está o dado que vai fazer você repensar: 60% das pequenas empresas que sofreram um ataque cibernético fecharam as portas em menos de 6 meses. Não é sobre medo, é sobre matemática simples: vulnerabilidades no seu código são passivos que podem destruir o negócio onde você trabalha.

A ISO 27001 funciona como um Sistema de Gestão de Segurança da Informação (SGIS) que:

• Mapeia riscos específicos do SEU contexto (nada de checklists genéricos que não se aplicam ao seu stack)
• Aplica controles proporcionais ao risco real (sem excesso, sem falta)
• Exige melhoria contínua (porque ameaças de ontem não são as de hoje)
• Integra segurança no ciclo de desenvolvimento (Secure SDLC não é opcional para profissionais)

O Que Acontece Quando Você Trata ISO 27001 Como "Coisa de Auditor" (Alerta: Não É Bonito)

Lembre-se do vazamento da Equifax? Um simples patch evitou exposição de dados de 147 milhões de pessoas e prejuízo de US$ 1,4 bilhão. Ou o incidente recente com MOVEit Transfer que afetou centenas de organizações? Esses não foram "ataques sofisticados", foram explorações de vulnerabilidades conhecidas que boas práticas de segurança teriam evitado.

No desenvolvimento de software, ignorar práticas alinhadas à ISO 27001 significa:

• Entregar código com falhas evitáveis que se tornam incêndios em produção
• Pagar 30x mais para corrigir uma vulnerabilidade em produção vs. durante desenvolvimento (IBM Cost of a Data Breach Report)
• Perder contratos com empresas que exigem certificação como pré-requisito mínimo
• Viver em modo de apagão de incêndio вместо de entregar valor real

Como Implementar ISO 27001 sem matar sua velocity (Guia Prático para Devs que Odeiam Burocracia)

Esqueça aquelas imagens de salas cheias de papéis. A ISO 27001 moderna é sobre incorporar segurança no seu fluxo existente e sim, isso pode até acelerar seu time a longo prazo.

1. Comece analisando riscos de verdade (Não a Toa)

//Abordagem amadora: verificar se tem chave e parar por aí
if (secrets.get("API_KEY") == null) {
    throw new IllegalStateException("Missing API key");
}

//Abordagem profissional: 
//entender o CONTEXTO do risco
public class ApiKeyRiskAssessment {
  public RiskLevel evaluateExposure() {
   // Pergunte: 
   // - Qual é a probabilidade de vazamento? 
   //  (Depende do armazenamento, logs, etc.)
   // - Qual seria o impacto? 
   // (Acesso total ao sistema de pagamento? 
   // Apenas leitura de dados públicos?)
   // - Quão fácil é detectar se vazou? 
   // Só assim você decide se investe em cofre de chaves, rotação 
   // automática ou aceita o risco documentado
 }
}

2. Trate segurança como requisito não-funcional (Sério Mesmo)

Sua definição de "Pronto" deve incluir automaticamente:

• Varredura de dependências vulneráveis (OWASP Dependency-Check, Snyk) no CI
• Análise estática de segurança (SAST) em cada PR
• Threat modeling para novas features críticas (não precisa ser BORING 30 minutos em um quadro já ajuda)
• Treinamento trimestral em secure coding específico para sua stack

3. Documente o suficiente (Não o Máximo)

A ISO 27001 exige evidências, não romance:

• Mantenha um risk register simples (planilha compartilhada com: risco, probabilidade, impacto, tratamento, responsável)
• Documente por que você aceitou ou mitigou cada risco (ex: "Aceitamos risco X porque o custo de mitigação > impacto potencial")
• Use evidências automatizadas (relatórios de scanner, logs de treinamento, screenshots de configuração)

O segredo que ninguém conta: ISO 27001 TE FAZ ENTREGAR MAIS RÁPIDO

Parece contra-intuitivo, mas equipes com SGIS maduro têm menor lead time e maior taxa de sucesso nas entregas. Por quê?

• Menos emergências de segurança interrompendo sprints importantes
• Maior confiança para inovar (você sabe que tem processos para gerir o risco novo)
• Menos retrabalho por falhas que poderiam ser evitadas em design
• Maior confiança do cliente – fechando negócios maiores e mais estáveis

Seu plano de ação de 15 Minutos (Comece AGORA)

1. Leia o guia executivo gratuito do Portal 27001 (5 minutos, eles explicam sem jargão de consultoria)
2. Faça uma avaliação relâmpago (10 minutos):
   • Quais são os 3 maiores riscos de segurança no seu projeto atual?
   • Para cada um: qual é a pior coisa que poderia acontecer se explorado?
3. Escolha UM controle do Anexo A da ISO 27001 para implementar nesta semana (ex: A.12.6.1 - Gestão de vulnerabilidades técnicas)
4. Compartilhe isso com sua equipe na próxima retro – segurança é esporte coletivo, não tarefa do "cara de segurança"

"Segurança não é um produto que você compra. É um processo que você incorpora no jeito de trabalhar." Princípio básico da ISO 27001

A ISO 27001 não vai atrapalhar sua velocidade, ela vai proteger o impacto do trabalho que você tanto se esforça para criar. Na próxima vez que alguém disser que "isso é burocracia excessiva", pergunte calmamente: "Você preferiria explicar um vazamento de dados para seus clientes ou passar uma hora documentando como tratamos esse risco específico?"

P.S. Se seu software lida com dados pessoais (LGPD/GDPR), financeiros ou de saúde, a ISO 27001 não é opcional, é o preço de entrada para ser levado a sério no mercado profissional. Não deixe para amanhã o que pode impedir um incidente hoje.

Quer ver como aplicar isso na prática? Veja os recursos da ISO 27001

Feito!

A era da IA Generativa: Ainda vale a pena aprender a programar?

Se você está começando agora na área de tecnologia ou já atua como desenvolvedor Júnior, provavelmente já se deparou com a pergunta: "Por que gastar meses estudando lógica, sintaxe e estruturas de dados se o ChatGPT, Gemini, Claude Code, ou GitHub Copilot escrevem o código em segundos?"

Antes de aprofundarmos, é preciso fazer uma distinção técnica fundamental: quando falamos popularmente em "IA", estamos simplificando um campo vasto da Ciência da Computação. O que utilizamos hoje para gerar código são, na verdade, Agentes de IA baseados em LLMs (Large Language Models - Grandes Modelos de Linguagem). Ferramentas como ChatGPT, Claude, Gemini e GitHub Copilot não "pensam" no sentido humano; elas são modelos probabilísticos altamente sofisticados que preveem o próximo token de código com base em padrões de bilhões de linhas de dados.

A sensação para muitos iniciantes é de que a barra de entrada subiu ou que a profissão está desaparecendo. No entanto, a realidade é oposta: nunca houve um momento tão estratégico para aprender a programar, desde que você entenda a diferença entre escrever código e engenharia de software.

1. O Código como Commodity: A Mudança de Paradigma

Para entender por que a programação ainda é essencial, precisamos primeiro aceitar que o "código" em si tornou-se uma commodity. No mercado de TI, uma commodity é algo que pode ser produzido em massa e tem pouco valor agregado se não houver um diferencial competitivo.

Para o cliente final ou para o dono de uma empresa, o código é apenas o meio para atingir um fim. O cliente não compra "um sistema em Java com Spring Boot", ele compra a solução para um problema de negócio (ex: "preciso que meu estoque seja atualizado em tempo real").

Os agentes de LLM são excelentes em gerar a sintaxe (o "como"), mas eles não possuem visão de negócio nem consciência do contexto organizacional (o "o quê" e o "porquê"). O desenvolvedor que foca apenas na sintaxe será substituído; o desenvolvedor que foca na resolução de problemas usando a tecnologia como ferramenta será promovido.

2. A Armadilha da "Ilusão de Competência"

Um dos maiores riscos para os estagiários e juniores hoje é a ilusão de competência. Isso acontece quando um estudante pede para um agente de IA gerar uma função complexa, o código funciona de primeira e ele assume que "sabe" como aquilo funciona.

O problema surge no momento do debug. Quando o código do LLM falha, e ele falha frequentemente em casos de borda (edge cases) — quem não domina os fundamentos não consegue rastrear o erro. Sem a base, você não é o piloto da IA, você é apenas um passageiro que espera que a máquina não bata.

A diferença entre Operador de Prompt e Engenheiro de Software

Critério	Operador de Prompt (Dependente)	Engenheiro de Software (Autônomo)
Abordagem	Tenta a sorte com prompts até o código "funcionar".	Planeja a arquitetura e usa a IA para implementar partes.
Validação	Executa o código e, se não deu erro, assume que está correto.	Analisa a complexidade temporal, espacial e a segurança.
Manutenção	Dificuldade em alterar o código sem quebrar outras partes.	Aplica princípios de SOLID e Design Patterns para escalabilidade.
Resolução de Bugs	Copia o erro no prompt e reza para a IA corrigir.	Usa debuggers, logs e conhecimento de memória/stack para resolver.

3. Os Pilares Inegociáveis: O que você DEVE aprender

Se os agentes de LLM geram o código, onde você deve focar seus estudos? A resposta é: nos fundamentos que a IA não consegue simular com consciência.

1. Lógica de Programação e Algoritmos: Você precisa entender como os dados fluem. Se você não sabe a diferença entre um Array e uma LinkedList, você não saberá pedir ao LLM a estrutura mais eficiente para o seu caso.
2. Estruturas de Dados: Saber quando usar um HashMap em vez de percorrer uma lista com um loop for é a diferença entre um sistema que escala e um sistema que trava.
3. Engenharia de Software:
   • SOLID: Para garantir que o código gerado pela IA não seja um "monolito" impossível de manter.
   • Design Patterns: Saber implementar um Observer ou um Factory para organizar a comunicação entre objetos.
   • Testes Automatizados: O LLM pode gerar o código, mas você deve escrever os testes unitários e de integração para provar que o código é confiável.
4. Arquitetura de Sistemas: Entender a diferença entre Monólitos, Microsserviços e Serverless. O agente de IA pode escrever a função, mas ele não desenha a topologia da rede ou a estratégia de cache do Redis.

4. O Agente de IA como o "Novo Compilador"

Historicamente, a programação sempre evoluiu para abstrações maiores. Antigamente, programava-se em binário, depois Assembly, depois C, depois linguagens de alto nível como Java e Python.

O uso de LLMs é apenas a próxima camada de abstração. Eles não substituem o programador, eles substituem a digitação manual de códigos repetitivos (boilerplate).

// Exemplo de código commodity 
// (Agente de LLM faz em 1 segundo):
public class User {
    private String name;
    private String email;
    // Getters e Setters repetitivos...
}

O valor real não está em escrever a classe acima, mas em decidir se esse User deve ser persistido em um banco NoSQL para performance de leitura ou em um Relacional para consistência ACID.

5. Considerações finais: O Futuro do Desenvolvedor

A pergunta "Ainda vale a pena aprender a programar?" deve ser substituída por: "Como posso me tornar um desenvolvedor que domina as ferramentas de LLM, em vez de ser dominado por elas?"

A responsabilidade final pelo software continua sendo do ser humano. Se o sistema de um banco falha ou se os dados de um hospital são vazados, a culpa não é do modelo de linguagem que gerou o snippet de código, mas do engenheiro que validou e implementou aquele código sem a devida análise crítica.

Portanto, para os estagiários e juniores: estudem a base. Aprendam a ler código. Questionem cada linha que a IA gera. Transformem-se em arquitetos de soluções. O código é a ferramenta, mas a engenharia é a arte. E a arte, por enquanto, continua sendo humana.

Feito!

Como encontrar e remover arquivos duplicados com essa ferramenta

Você já ficou sem espaço no disco e suspeitou que tinha arquivos duplicados ocupando espaço desnecessário? O fdupes é a ferramenta perfeita para resolver esse problema!

O que é o fdupes?

O fdupes é um programa de linha de comando que identifica arquivos duplicados em um ou mais diretórios. Ele usa uma combinação intelligente de tamanho de arquivo e hash MD5/SHA1 para encontrar duplicatas de forma eficiente, sem precisar comparar byte a byte.

Instalação

Debian/Ubuntu

sudo apt install fdupes

Fedora

sudo dnf install fdupes

Arch Linux

sudo pacman -S fdupes

macOS (via Homebrew)

brew install fdupes

Como usar

Exemplo básico: encontrar duplicatas

fdupes ~/Downloads

Saída esperada:

./Downloads/documento.txt
./Downloads/documento-copia.txt

Ver detalhes dos arquivos duplicados

fdupes -l ~/Downloads

Saída com tamanho:

   1024 ./Downloads/documento.txt
   1024 ./Downloads/documento-copia.txt

Procura recursiva em subdiretórios

fdupes -r ~/Documentos

Primeira opção é a original (mantém primeiro)

fdupes -d ~/Downloads

O fdupes vai pedir confirmação para manter ou excluir cada conjunto de duplicatas.

Opções mais úteis

Lista de opções disponíveis fdupes

Opção	Descrição
-r, --recurse	Procura recursivamente nos diretórios
-l	Lista apenas com detalhes de tamanho
-S, --size	Mostra tamanho dos arquivos duplicados
-m, --summarize	Mostra estatísticas resumidas
-d, --delete	Deleta duplicatas (cuidado!)
-N, --noprompt	Com -d, deleta sem pedir confirmação
-f, --omitfirst	O primeiro arquivo do grupo é considerado original
-n, --noempty	Ignora arquivos vazios
-H, --hardlinks	Trata hard links como duplicatas
-q, --quiet	Modo silencioso
-1, --sameline	Lista em uma única linha
-h	Mostra ajuda

Dicas de uso

Encontrar e listar sem deletar (modo seguro)

fdupes -rl ~/Downloads | less

Exemplo prático completo

1. Primeiro, descubra onde estão as duplicatas

fdupes -r ~/Downloads

2. Liste os detalhes para ver quanto espaço pode liberar

fdupes -rl ~/Downloads

3. Crie uma pasta para backups antes de excluir

mkdir ~/duplicadas_backup

4. Copie as duplicatas para a pasta de backup

fdupes -r ~/Downloads -d ~/duplicadas_backup

5. Confirme que as cópias estão na pasta de backup

ls ~/duplicadas_backup

Por que usar fdupes?

• Economia de espaço: Arquivos duplicados podem consumir gigabytes
• Organização: Ajuda a limpar projetos e pastas bagunçadas
• Identificação de projetos duplicados: Encontra projetos/clones repetidos
• Limpeza de backup: Remove cópias desnecessárias

Cuidado!

• Sempre use -l primeiro para listar sem alterar nada
• Faça backup antes de deletar com -d
• O fdupes pode não funcionar bem com links simbólicos
• Arquivos com metadados diferentes mas conteúdo igual são considerados duplicatas

Referência

fdupes man page - Linux Command Library

Feito!

MUDANÇA NO CNPJ: O que você precisa fazer no seu projeto

A Receita Federal confirmou: a partir de julho de 2026, o CNPJ será alfanumérico (com letras e números). Novo formato: 14 caracteres sendo 12 primeiros alfanuméricos + 2 dígitos verificadores (DV) numéricos.

Isso vai quebrar muitos sistemas. Vamos aos impactos:

1. CNPJ como Integer no banco de dados

Problema: CNPJs novos terão letras (ex: 12AB3456C0001). Tipo INTEGER não suporta letras.

Solução: Migrar coluna para VARCHAR(18) ou CHAR(14), mantenham o tamanho fixo para compatibilidade com sistemas legados.

2. CNPJ como Primary Key

Problema: PKs inteiras não funcionam + índices unique baseados em Integer falharão para novos registros.

Solução:

• Alterar tipo da PK para VARCHAR(18) ou CHAR(14)
• Atualizar foreign keys em todas as tabelas relacionadas
• Regenerar índices unique

3. Validação de DV (Módulo 11)

Problema: Algoritmo atual não reconhece letras.

Solução: Ver algoritmo em pseudocódigo abaixo.

4. Máscaras e formats existentes

Problema: XX.XXX.XXX/0001-XX pode não funcionar com letras.

Solução: Criar máscara flexível que aceite alfanumérico.

5. Integração com APIs e ERPs

Problema: Sistemas legados que recebem CNPJ como número quebrarão.

Solução: Revisar APIs, contratos, e integrações -> tipar como string, não integer.

Cronograma

• Julho 2026: Primeiros CNPJs alfanuméricos emitidos
• CNPJs atuais: Permanecem válidos (não precisam migrar)

Ação imediata

• ✓ Audit no banco: identifique colunas CNPJ com tipo Integer
• ✓ Planeje migração para VARCHAR/CHAR
• ✓ Teste o novo algoritmo de validação
• ✓ Revise integrações externas

Algoritmo de Validação do DV (Módulo 11)

O algoritmo a seguir funciona para CNPJs numéricos (atuais) e CNPJs alfanuméricos (novos).

Tabela de Conversão

Caractere	Valor para cálculo
0-9	0-9 (valor numérico)
A	17
B	18
C	19
D	20
E	21
F	22
G	23
H	24
I	25
J	26
K	27
L	28
M	29
N	30
O	31
P	32
Q	33
R	34
S	35
T	36
U	37
V	38
W	39
X	40
Y	41
Z	42

Pseudocódigo

FUNÇÃO obterValorCaractere(caractere):
    SE caractere >= '0' E caractere <= '9':
        RETORNAR inteiro(caractere)
    FIM SE
    
    SE caractere >= 'A' E caractere <= 'Z':
        codigoASCII <- inteiro(caractere)
        RETORNAR codigoASCII - 48
    FIM SE
    
    RETORNAR -1  // Caractere inválido
FIM FUNÇÃO


FUNÇÃO calcularDV(cnpj, posicaoDV):
    // posicaoDV = 1 para primeiro DV, 2 para segundo DV
    
    SE posicaoDV == 1://Primeiros 12 caracteres do CNPJ
        pesos <- [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
        digitos <
    SENÃO://Primeiros 12 caracteres do CNPJ + primeiro DV
        pesos <- [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
        digitos <
    FIM SE
    
    soma <- 0
    PARA i DE 0 ATÉ comprimento(digitos) - 1:
        valor <- obterValorCaractere(digitos[i])
        soma <- soma + (valor * pesos[i])
    FIM PARA
    
    resto <- soma MOD 11
    
    SE resto <= 1:
        DV <- 0
    SENÃO:
        DV <- 11 - resto
    FIM SE
    
    RETORNAR DV
FIM FUNÇÃO


FUNÇÃO validarCNPJ(cnpj):
    // Remove máscara (pontos, barras, hífen)
    cnpjLimpo <- limparMascara(cnpj)
    
    SE comprimento(cnpjLimpo) != 14:
        RETORNAR FALSO
    FIM SE
    
    // Extrai os DVs informados no CNPJ
    dv1Informado <- inteiro(cnpjLimpo[12])
    dv2Informado <- inteiro(cnpjLimpo[13])
    
    // Calcula primeiro DV
    dv1Calculado <- calcularDV(cnpjLimpo, 1)
    
    SE dv1Informado != dv1Calculado:
        RETORNAR FALSO
    FIM SE
    
    // Calcula segundo DV
    dv2Calculado <- calcularDV(cnpjLimpo, 2)
    
    SE dv2Informado != dv2Calculado:
        RETORNAR FALSO
    FIM SE
    
    RETORNAR VERDADEIRO
FIM FUNÇÃO

Exemplo de Implementação em JavaScript

function obterValorCaractere(char) {
    if (char >= '0' && char <= '9') {
        return parseInt(char, 10);
    }
    const codigoASCII = char.charCodeAt(0);
    if (codigoASCII >= 65 && codigoASCII <= 90) {
        return codigoASCII - 48;
    }
    return -1;
}

function calcularDV(cnpj, posicaoDV) {
    const pesos = posicaoDV === 1 
        ? [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
        : [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
    
    const digitos = posicaoDV === 1 
        ? cnpj.substring(0, 12) 
        : cnpj.substring(0, 12) + cnpj.charAt(12);
    
    let soma = 0;
    for (let i = 0; i < digitos.length; i++) {
        const valor = obterValorCaractere(digitos[i]);
        soma += valor * pesos[i];
    }
    
    const resto = soma % 11;
    return resto <= 1 ? 0 : 11 - resto;
}

function validarCNPJ(cnpj) {
    const cnpjLimpo = cnpj.replace(/[.\/-]/g, '');
    
    if (cnpjLimpo.length !== 14) {
        return false;
    }
    
    const dv1 = parseInt(cnpjLimpo[12], 10);
    const dv2 = parseInt(cnpjLimpo[13], 10);
    
    if (calcularDV(cnpjLimpo, 1) !== dv1) {
        return false;
    }
    
    if (calcularDV(cnpjLimpo, 2) !== dv2) {
        return false;
    }
    
    return true;
}

// Testes
// true (CNPJ atual válido)
console.log(validarCNPJ('83.847.133/0001-25')); 

// true (CNPJ novo fictício válido)
console.log(validarCNPJ('53.RRV.R8C/9PHH-34')); 

// false
console.log(validarCNPJ('12345678900013')); 

// false
console.log(validarCNPJ('77.888.364/0001-81')); 

// false
console.log(validarCNPJ('X3.VGJ.TBC/0001-43')); 

Referências

Instrução Normativa RFB nº 2.229/2024

Nota Técnica Conjunta CNPJ Alfanumérico 2025.001

Nota Técnica Conjunta COCAD/SUARA/RFB nº 49/2024

A mudança não é complexa, mas exige atenção. Quem esperar o dia pode enfrentar problemas de última hora.

Feito!