DEV Community: Marcel Scognamiglio

Vibe Coding: Embracing Creativity and Chaos in Software Development

Marcel Scognamiglio — Thu, 03 Apr 2025 13:31:50 +0000

Then, one day in Twitter, a phenomenon known as “Vibe Coding” has emerged.

This term encapsulates the idea of coding without constraints, without the formal shackles of requirements. It’s like handing a child a palette of paints and letting them create freely.

However, much like a house with pristine white walls, this freedom can quickly turn into chaos.

“Vibe Coding” has its place, especially in environments that value innovation and creativity. Within an Innovation Hub or during a Hackathon, where the exploration of new ideas is encouraged, this approach can yield valuable insights.

However, outside these controlled spaces, it’s crucial to impose boundaries. Without procedures, “Vibe Coding” can lead to a cascade of errors. These slip-ups, while essential for learning, can result in abandoning projects due to entropy(1) in the codebase.

Much like you wouldn’t scold a child for abandoning one drawing for another, developers should be allowed to pivot without fear of repercussions. The key is to channel this innovative energy within a safe space, where mistakes don’t lead to disastrous consequences.

Ultimately, “Vibe Coding” can be a powerful tool for innovation, as long as it’s used wisely.”

⸻

(1) Code Entropy: A term referring to the gradual decline in a codebase’s structure and clarity over time. As more developers contribute or make changes without proper guidelines, the code can become messy, harder to understand, and more prone to bugs.

RAG: Como IA pode ser inteligente sem reter dados?

Marcel Scognamiglio — Mon, 17 Feb 2025 14:45:59 +0000

A maioria dos sistemas de IA depende de um modelo treinado em grandes volumes de dados. Esse modelo aprende padrões e responde com base em informações armazenadas. O problema? Isso compromete privacidade, dificulta atualizações e pode levar a respostas obsoletas ou enviesadas.

O Retrieval-Augmented Generation (RAG) propõe uma abordagem diferente: em vez de depender de aprendizado prévio, ele recupera informações no momento da consulta e gera respostas contextuais sem armazenar nada permanentemente.

Como o RAG funciona?

O RAG combina dois processos:
1. Recuperação de informações
• O sistema busca os dados relevantes no momento da requisição (por exemplo, em um banco de dados, documentos internos ou mensagens recentes).
2. Geração de resposta
• A IA recebe os dados recuperados como contexto e gera uma resposta personalizada com base apenas neles.

Esse modelo é útil para aplicações onde a informação muda constantemente e onde privacidade é uma preocupação central.

Exemplo prático de RAG

Imagine que estamos construindo um assistente interno de suporte técnico que responde dúvidas sobre uma API. Em vez de treinar um modelo que memorize toda a documentação, o RAG busca informações em tempo real e gera respostas com base na versão mais recente.

Pseudocódigo

function responderPergunta(pergunta, usuario) {
documentos = buscarBaseDeConhecimento(pergunta, usuario)
contexto = formatarContexto(documentos, pergunta)
resposta = modeloDeIA.gerarTexto(contexto)
return resposta
}

Esse fluxo garante que as respostas estejam sempre alinhadas com as informações mais atualizadas e restritas ao que o usuário tem permissão para ver.

TypeScript

async function responderPergunta(pergunta: string, usuarioId: string): Promise {
const documentos = await buscarDocumentos(pergunta, usuarioId);
const contexto = formatarContexto(documentos, pergunta);
return await gerarRespostaIA(contexto);
}

async function buscarDocumentos(pergunta: string, usuarioId: string): Promise {
return await database.query(SELECT conteudo FROM docs WHERE usuario_id = ?, [usuarioId]);
}

async function gerarRespostaIA(contexto: string): Promise {
return await iaModel.generateText({ prompt: contexto });
}

Aqui, a IA não aprende nada de forma permanente. Cada requisição gera uma nova resposta baseada no contexto atual.

Vantagens do RAG
1. Privacidade e segurança
• Nenhum dado sensível precisa ser armazenado ou aprendido pelo modelo.
• Ideal para aplicações empresariais e dados internos.
2. Sempre atualizado
• A IA sempre responde com base nos dados mais recentes.
• Útil para suporte técnico, busca de documentos e análise de dados dinâmicos.
3. Menos viés e menos alucinações
• Como o modelo não tem memória própria, ele não inventa informações fora do contexto.
• O risco de respostas imprecisas ou enviesadas é menor.
4. Redução de custo
• Modelos gigantes precisam de treinamento contínuo, o que é caro.
• No RAG, basta atualizar a base de conhecimento.

Desafios e limitações do RAG

Nem tudo são vantagens. O RAG tem desafios que precisam ser considerados:
1. Latência
• O modelo precisa buscar dados antes de gerar uma resposta, o que pode ser mais lento do que um modelo tradicional que já tem conhecimento armazenado.
2. Dependência da fonte de dados
• Se os dados buscados estiverem desatualizados ou mal estruturados, as respostas serão igualmente ruins.
• A qualidade do RAG depende diretamente da qualidade do repositório de informações.
3. Janelas de contexto limitadas
• Modelos de IA têm um limite no volume de informações que podem processar de uma vez.
• Para buscas muito extensas, pode ser necessário resumir os dados antes de enviá-los para a IA.
4. Maior complexidade arquitetural
• Exige integração entre sistemas de busca e modelos generativos.
• Necessário garantir que as permissões de acesso sejam respeitadas para evitar vazamento de dados.

Para que RAG é mais indicado?

Dado seu funcionamento, o RAG é ideal para cenários onde a informação precisa ser contextual, segura e sempre atualizada.

Casos de uso recomendados

✅ Sistemas de suporte técnico
• Assistentes internos para responder dúvidas sobre documentação.
• Bots de atendimento ao cliente que precisam consultar dados dinâmicos.

✅ Pesquisa em grandes bases de conhecimento
• Sistemas de busca internos em empresas.
• Recuperação de jurisprudências para advogados.

✅ IA para análise de documentos
• Resumos automáticos de relatórios.
• Extração de insights em tempo real a partir de múltiplas fontes.

Casos onde RAG pode não ser a melhor opção

❌ Aplicações onde latência é um problema crítico
• Chatbots em tempo real podem sofrer atrasos devido à necessidade de buscar e processar informações antes da resposta.

❌ Sistemas que precisam aprender padrões ao longo do tempo
• Modelos preditivos para tendências de mercado ou diagnóstico médico funcionam melhor com aprendizado contínuo.

Conclusão

O RAG representa uma mudança de paradigma: em vez de ensinar modelos a memorizar tudo, ele os ensina a buscar conhecimento no momento certo. Isso garante respostas mais precisas, seguras e atualizadas.

Por outro lado, ele exige mais estruturação dos dados e pode ter desafios de latência. Para quem busca IA corporativa, segura e confiável, o RAG é uma das abordagens mais promissoras.

O futuro da IA pode não estar nos modelos que sabem tudo, mas sim nos modelos que sabem onde procurar.

Agora o texto está completo, cobrindo vantagens, desvantagens e aplicações do RAG, além de trazer exemplos técnicos em pseudocódigo e TypeScript.

Me avise se quiser ajustes.

Vamos Ser Sinceros: Seu Código Já Está Sendo Escrito por IA – Sua Empresa Está Preparada Para Isso?

Marcel Scognamiglio — Thu, 13 Feb 2025 13:46:03 +0000

Vamos direto ao ponto: se você está programando numa terça-feira à noite, querendo sair o mais rápido possível da frente da tela para ir jogar seu futebol ou ir passar mais tempo com seus doguinhos, boa parte do seu código está sendo escrito pela IA.

E se isso vale para você, por que não seria o caso dos seus colegas? Dos sêniores da sua empresa? Dos júniores? Das outras empresas?

Isso já está acontecendo, quer você queira admitir ou não. Uma curiosidade: descobri essa semana que tem gente que tem vergonha de admitir que usa IA para gerar código. Como se isso fosse um atestado de incompetência, quando na verdade isso é só o novo normal.

Voltando ao assunto: cada vez mais código em produção está sendo gerado por IA usando ferramentas como Bolt, Windsurf, Copilot ou Cursor. Fato. E isso levanta algumas perguntas que poucas empresas estão realmente fazendo.

Seu time está pronto para garantir que esse código gerado é seguro?
A pipeline de push de código novo para a produção está preparada para lidar com essa nova realidade?
Esse código está sendo revisado como deveria neste novo cenário? Ou está só passando nos testes e indo para o ar?

No meio desse caos, uma coisa é certa: aquele(a) que souber controlar e proteger o código da IA dentro da empresa vai se tornar peça-chave na engenharia de software.

Neste texto, trago minhas experiências pessoais e de outros desenvolvedores que passaram (ou estão passando) por essa transição. Reuni as perguntas que você precisa fazer – e responder – para garantir que sua empresa não está entrando em uma armadilha.

E no final, um bônus: como você pode se tornar uma autoridade, não em IA, mas em garantir qualidade e segurança do código.

Você já percebeu como o código gerado por IA é um cobertor curto?

Se você já gerou código do ZERO com IA, sabe exatamente do que estou falando. No começo, é tudo lindo: você resolve problemas em minutos, adiciona funcionalidades rapidamente, sente que está acelerando o desenvolvimento.

Mas aí começam os problemas.

Toda alteração que você pede para a IA altera mais do que deveria.

Você ajusta um bug e outro aparece.
Você melhora uma funcionalidade e descobre que outra parou de funcionar.
Você tenta refatorar e o código gerado sai irreconhecível.

Isso acontece porque a IA não tem um entendimento real do projeto. "Ah mas o Cursor deixa a AI ler meu codebase", sim mas contexto e entendimento são coisas distintas. AI gera código baseado em padrões, mas sem considerar o impacto real das mudanças, sem "enxergar" o impacto na UI, ou em outros pontos da arquitetura.

O resultado? Um cobertor curto. Se cobre um lado, outro fica exposto. Se melhora a performance, perde a legibilidade. Se adiciona uma funcionalidade, aumenta a dívida técnica.

Para isto as dicas são:

Use AI para obter contexto através de perguntas antes de começar a desenvolver num codebase novo;
Use AI para fazer mudanças em contextos controlados e tarefas repetitivas;
Para tarefas mais complexas, use AI em seu IDE em conjunto com os bons e velhos commits bem documentados como checkpoints; Assim caso a AI comece a delirar e mudar mais do que deve, você sempre terá como retroceder.

Se a IA está criando código, quem é o dono?

Quando um desenvolvedor escreve código, ele tem domínio sobre a implementação. **Ele sabe o que fez **e por que fez.

Mas quando a IA gera código, quem é o responsável?

Se ninguém do time criou aquele código, ninguém tem controle total sobre ele. Isso significa que:

Ninguém sabe exatamente como ele funciona.
Ninguém pode garantir que não tem uma vulnerabilidade oculta.
Ninguém consegue dar manutenção sem precisar desmontar tudo.

E tem um agravante: o código gerado pela IA nem sempre é feito para humanos lerem. Muitas vezes, ele é altamente performático, mas completamente ilegível.

Já passei por isso com JavaScript (Node e React), PHP e Rust. E posso garantir: às vezes é mais rápido escrever o código do zero do que tentar entender o que a IA fez.

Sua revisão de código é rigorosa o bastante para lidar com a quantidade de código feito por AI que está indo pra lá?

Agora que Pull Requests inteiros podem ser gerados por IA, os processos de revisão precisam evoluir urgentemente.

Testes passando não são garantia de que o código está seguro.

Se a IA alterou mais do que deveria, isso precisa ser visto antes do merge.
Se o código não tem cobertura de testes suficiente, ele não deveria entrar na produção.

Sua empresa já ajustou os processos de revisão para isso?

Se a resposta for “não”, eu vejo uma oportunidade pra você ser quem irá levantar a mão.

A IA deve ser tratada como um sênior?

Se você trata IA como um desenvolvedor sênior, vai ter problemas.

Ela pode gerar código rápido, mas não entende contexto do negócio, não pensa em arquitetura e não sabe tomar decisões de longo prazo.

O jeito certo de usar IA é como um júnior promissor.

Boa para acelerar tarefas repetitivas.
Ótima para refatoração assistida.
Útil para geração de testes.
Mas péssima para decisões críticas sem supervisão.

Quem souber lidar com isso da maneira certa vai se tornar referência dentro da empresa.

Seu papel como programador está mudando?

Não é sobre a IA substituir programadores, mas como ela está redefinindo o que significa ser um bom programador.

O desenvolvedor que se destacar não será aquele que usa IA para escrever código. Isso vai se tornar o mínimo esperado.

O diferencial será:
Saber proteger o código e garantir que a IA não está criando um Frankenstein de funções quebradas.
Ser referência na revisão de código, garantindo segurança e boas práticas.
Conseguir explicar funcionalidades de forma clara para o time e stakeholders, sem se prender a tecnicismos desnecessários.

As empresas vão continuar precisando de** desenvolvedores que fazem as coisas funcionar**; porém agora como fazer a IA trabalhar a favor do produto, e não contra.

Você está preparado para essa nova realidade?

Código gerado por IA não é mais uma tendência – é uma realidade. Se você ainda não está lidando com isso, seu código já está sendo impactado e você nem percebeu.

Como sua empresa está lidando com esse aumento no código gerado por IA?

Seu processo de revisão já mudou para acompanhar essa nova realidade?
Você se vê como alguém que pode se tornar referência em proteger o código da IA dentro da empresa?

Vamos discutir. E se esse texto fez sentido para você, compartilhe com alguém que ainda acha que IA não está mudando o jogo. Porque já mudou.

I Killed the Backend — And Here’s Why Simplicity Is the Ultimate Power Move

Marcel Scognamiglio — Sat, 02 Nov 2024 23:16:18 +0000

Yes, you read that right. I killed the backend of my project, and I did it with zero regrets. Let’s talk about why.

In a world where we, as developers, are often pressured to add complexity to our systems — more layers, more services, more integrations — I decided to go the opposite way. I decided to simplify violently.

The project in question is called AutoMenu, a service I built two years ago that powers several coffee shops in the Vale do Paraíba region. It used to run on a robust headless CMS (Strapi), with a full backend setup that I spent countless hours maintaining. But one day, I asked myself: Why am I dedicating so much energy to maintenance when I could be focusing on what really matters?

So, I did it. I shut down the backend. 💀

Why Google Sheets Replaced My Database

Here’s where it gets interesting. I replaced the entire backend with… Google Sheets. Yes, a simple Google Sheet where clients manage their products, and a single codebase hosted on Vercel using Next.js handles everything, from front-end to back-end logic.

And before the complexity enthusiasts lose their minds, let me explain: It works. The system doesn’t process payments or require ACID compliance, so why over-engineer it? Instead, I validate and cache data efficiently with Next.js route handlers, making it lean and maintenance-free.

The Philosophy of Violent Simplification

✨ Creating is gold, but maintaining is diamond. ✨ And every line of code you write is a future liability. Maintenance is a time sink that traps you, eating up your energy and freedom. The more complexity you add, the more you have to manage — and the more chained you become to your project.

This isn’t just a technical decision; it’s a strategic one. Companies could benefit massively from adopting a similar mindset. Imagine cutting down on unnecessary microservices, bloated databases, and overly complicated architectures that don’t deliver measurable value.

When to Say No to More Features

I face constant pressure to add things like user data collection and payment processing. But here’s the thing: Every feature needs to justify its existence. If it’s not bringing at least double the revenue or solving a problem worth 10X the effort, it’s a distraction.

And distractions are expensive. They turn simple systems into high-maintenance monsters. Most businesses aren’t willing to pay for that level of complexity, and I refuse to sacrifice efficiency for the sake of feature creep.

A New Movement: Intelligent Simplification

I’m calling for a movement. A push to simplify with ruthless intelligence. To cut out the fluff and streamline systems from day one. This isn’t laziness; it’s strategic thinking. Use your IQ to design lean architectures that deliver value without drowning in maintenance.

Think about it: Do you want to spend your career fighting fires in overcomplicated systems, or do you want to simplify and focus on what really matters? Simplifying violently is not just about less code — it’s about more freedom, more focus, and more impact.

So, let’s have this conversation. Are you ready to kill the unnecessary parts of your projects and embrace simplicity? Or will you keep adding complexity for complexity’s sake?

💬🔥 Let’s debate. Because sometimes, the boldest move is to simplify violently — and live freely

Not All Is About AI – Here Are 10 Problems I Solved Using Code for Real Businesses (None Involving AI!)

Marcel Scognamiglio — Fri, 20 Sep 2024 15:30:03 +0000

In a world obsessed with artificial intelligence, it can feel like every groundbreaking solution must involve machine learning or predictive algorithms. But let me share a little secret: real, transformative business solutions don’t always need AI.

Over the past year, I tackled complex problems for companies that demanded innovative and scalable solutions—none of which involved AI. From security enhancements to workflow automations, I used reliable coding techniques to drive major business impact.

Here are 10 problems I solved that made a difference:

Securing the User Base with MFA 🔒
To safeguard user accounts, I integrated multi-factor authentication (MFA) into a popular web application. The result was an added layer of security, protecting users and improving overall trust in the app.
Building a Reusable Web Ecosystem 🌐
Developed a full-fledged web app incorporating a reusable design system and a knowledge base (LMS). This ensured scalability and reduced duplication across multiple systems, streamlining documentation and training processes.
Speeding Up Development with Global Components 🚀
For a WordPress-powered marketing site, I introduced Global Components to optimize development cycles. This approach significantly boosted development and bug-fix speed, streamlining the process and making the platform more agile.
Enhancing SEO with Programmatic Pages 📈
Built a proof of concept (POC) for a marketing website that automatically generates SEO-friendly pages based on targeted keywords. The site structure was designed for scalability and conversion optimization, without the need for any AI-driven tools.
Crafting a Full-Stack Marketplace 🛒
Developed a full-stack marketplace POC utilizing modern web technologies, complete with an integrated payment system. This marketplace demonstrated smooth product management and transaction flows, laying the foundation for a scalable e-commerce platform.
Simplifying Authentication with SSO 🧩
Implemented Single Sign-On (SSO) across multiple systems, consolidating user authentication into a single, streamlined process. This simplified both user access and administrative tasks, enhancing security without introducing unnecessary complexity.
Automating Business Workflows ⚙️
Designed an automated workflow system to manage various business processes efficiently. This headless solution enabled business users to create workflows without developer involvement, significantly reducing time to market for new initiatives.
Building a Dynamic Notification System 📲
Implemented a robust notification center within the app, allowing notifications to be easily triggered from various systems. This improved communication flow across different departments and platforms, using a low-code environment to speed up deployment.
Ensuring Best Practices in Event-Driven Systems 🎯
Helped develop a custom package that enforced best practices for event-driven systems, ensuring data validation and proper architecture were followed. This maintained the integrity and consistency of critical business rules.
Delivering Front-End Features That Matter 💥
Over the course of multiple projects, I developed and delivered more than 10 significant front-end features using a variety of frameworks. Each of these features enhanced user experience and delivered business value, proving that well-implemented code often outshines the trendiest AI solution.

The Takeaway: Not Every Problem Needs AI
While AI often gets the spotlight, many real-world business problems are best solved with tried-and-true engineering methods. From securing apps to automating workflows, these achievements prove that robust coding can deliver significant results without the need for complex algorithms or AI models.

When it comes to real business impact, it’s not always about the technology you use—it’s how you use it.

Deixando a Matrix: A Jornada de Confiança e Sucesso de um Desenvolvedor Brasileiro

Marcel Scognamiglio — Fri, 13 Sep 2024 14:21:21 +0000

Imagine só: eu estou em uma conferência no Zoom, com dezenas de rostos atentos na tela. Cada um deles está esperando pela minha apresentação, onde vou mostrar o esboço de um novo sistema de arquitetura que desenvolvi do zero, pronto para ser implementado em uma empresa altamente competitiva nos Estados Unidos no próximo ano. Isso é sucesso. Esse é o momento com o qual muitos sonham. Mas, se você me dissesse há um ano que eu estaria aqui, eu não teria acreditado.

Há apenas um ano, eu era um desenvolvedor front-end em uma empresa no Brasil, me sentindo preso e frustrado. Meu trabalho parecia uma série de “desafios suficientes”—nunca o bastante para me impulsionar, nunca o bastante para me sentir realizado. O feedback era sempre o mesmo: “Você está fazendo o que é esperado de você, mas não é o suficiente para uma promoção.” Eu me sentia preso, em um ciclo que me fazia questionar minhas próprias habilidades. Comecei a acreditar que talvez eu não fosse bom o suficiente. Talvez eu tivesse chegado ao meu limite.

Mas hoje, tudo é diferente. Eu recebi um aumento mais do que merecido, e minhas responsabilidades cresceram muitas vezes. Estou construindo sistemas, colocando-os em produção e orientando outros desenvolvedores—coisas que um dia pensei estar fora do meu alcance. Como cheguei até aqui? Deixe-me te contar essa jornada.

O Começo:

Um ano atrás, eu estava em um mundo completamente diferente. Eu trabalhava como desenvolvedor front-end em uma empresa no Brasil. Era um emprego estável, pagava as contas, mas era só isso. Os desafios existiam, mas eram apenas o suficiente para manter as coisas andando, nunca o suficiente para me fazer sentir realmente engajado ou realizado. Eu queria mais—mais aprendizado, mais crescimento, mais oportunidades. Mas o feedback que eu recebia era desanimador: “Você está fazendo o que é esperado de você, mas não é o suficiente para uma promoção.”

Comecei a questionar a mim mesmo. Talvez eu não fosse tão bom quanto pensava. Talvez minhas habilidades não fossem tão afiadas quanto eu acreditava. Esse ciclo constante de dúvida começou a pesar em mim. Sou autodidata e adoro desafios, mas o ambiente em que eu estava parecia estar me segurando. A empresa não me desafiava e, em vez de crescer, eu sentia que estava encolhendo lentamente em uma versão de mim mesmo que eu não reconhecia.

Mas, lá no fundo, eu sabia que tinha mais a oferecer. Eu não estava pronto para aceitar que aquilo era o máximo que eu podia alcançar. Percebi que, se quisesse sair desse ciclo, teria que voltar a acreditar em mim mesmo, mesmo quando parecia que o mundo ao meu redor não acreditava. Precisava encontrar uma maneira de criar meus próprios desafios, de ultrapassar meus limites e provar, primeiro para mim e depois para os outros, que eu era capaz de muito mais. Eu sabia que não podia esperar que alguém me desse uma chance—eu tinha que criá-la sozinho.

O Ponto de Virada:

O ponto de virada não veio com um grande anúncio ou uma oferta de emprego que mudasse a vida. Foi mais como uma cena de Matrix. Eu percebi que estava preso em uma realidade que não era minha—uma realidade construída em torno de limitações, autocrítica e falta de crescimento. Eu precisava sair da Matrix, tomar a pílula vermelha, e ver até onde eu poderia ir se me empurrasse além das fronteiras que haviam sido estabelecidas ao meu redor.

Sair da Matrix significou enfrentar um dos maiores desafios para qualquer desenvolvedor brasileiro: dominar o inglês. No Brasil, crescemos falando português, e o inglês é um mundo completamente diferente. Não é apenas uma língua; é a porta de entrada para inúmeras oportunidades. Decidi tratar o aprendizado de inglês como se fosse aprender uma nova linguagem de programação. Eu sabia que precisava ser fluente nisso, assim como era em JavaScript ou Python.

Me esforcei muito para melhorar meu inglês de todas as formas possíveis—lendo artigos, assistindo vídeos, codificando em inglês e praticando falar e escrever todos os dias. Mergulhei de cabeça, tratando isso como o meu projeto mais importante. Eu sabia que, se pudesse me comunicar de forma eficaz em inglês, poderia abrir portas que sempre pareceram fechadas para mim.

Esse foco no inglês não era apenas sobre aprender uma língua; era sobre expandir meu mundo, meu alcance e meu potencial. Era a minha chave para sair da Matrix e entrar em um espaço onde as possibilidades eram infinitas.

Então, veio o momento que mudou tudo. Parei de esperar pela oportunidade perfeita e comecei a criá-la. Comecei a dedicar horas extras para aprender novas habilidades, explorar novas tecnologias e trabalhar em projetos paralelos que me empolgavam. Conectei-me com pessoas fora do meu círculo habitual, participei de comunidades, assisti a webinars e procurei pessoas que já haviam percorrido o caminho que eu queria trilhar.

Eu escolhi essas tecnologias após pesquisar tendências de mercado e analisar quais habilidades eram mais procuradas. Mas não parei apenas no aprendizado—queria provar que podia usar essas habilidades em um contexto real.

Então, eu assumi um grande risco. Decidi criar um aplicativo gratuito para um cliente real—uma padaria local. Não era pelo dinheiro; era sobre criar algo tangível que pudesse mostrar minhas habilidades. Usei o stack de tecnologia mais moderno que eu estava aprendendo e coloquei meu coração naquele projeto. Foi um desafio gerenciar tudo, do backend ao frontend, mas eu sabia que aquela era a minha chance de mostrar o que eu podia fazer. O risco valeu a pena—o aplicativo ainda é usado até hoje por aquela padaria, servindo como um testemunho das minhas habilidades e da minha disposição de ir além do esperado.

A Jornada para a Confiança:

Depois de sair da Matrix, não havia como voltar atrás. Percebi que construir confiança não era algo que acontecia da noite para o dia. Não era uma onda súbita de crença em mim mesmo; era algo que eu precisava conquistar, passo a passo, por meio de ações que me empurravam para fora da minha zona de conforto.

Decidi fazer do meu crescimento uma prioridade. Comecei a estabelecer metas pequenas e alcançáveis que me ajudassem a ganhar impulso. Cada meta era como um bloco de construção, e com cada nova conquista, minha confiança crescia um pouco mais. Assumi projetos que estavam fora da minha expertise imediata, mergulhando no desenvolvimento de backend e design arquitetural—áreas pelas quais sempre tive curiosidade, mas nunca tive a chance de explorar.

O aprendizado se tornou minha rotina diária. Comprometi-me a estudar novas frameworks, tecnologias e linguagens de programação, mas também sabia que, para realmente me destacar, precisava refinar minhas habilidades de comunicação, especialmente em inglês. Fiz aulas particulares de inglês com um professor dedicado, praticando todos os dias para melhorar não apenas a fala, mas também a escuta, escrita e compreensão. Abordei o inglês como se fosse uma nova linguagem de programação—uma que eu precisava dominar para abrir novas oportunidades.

Não parei por aí. Eu sabia que, para me tornar visível, precisava trabalhar na minha marca pessoal. Comecei a criar conteúdo que ajudasse outros desenvolvedores, compartilhando minha jornada, minhas percepções e as lições que estava aprendendo ao longo do caminho. Escrevi artigos, compartilhei dicas e documentei meu progresso nas redes sociais e em plataformas de desenvolvedores. Eu queria construir um perfil que não fosse apenas visto, mas respeitado, que mostrasse minha paixão pelo crescimento e minha disposição de ajudar os outros.

O networking também desempenhou um grande papel. Procurei pessoas que admirava, tanto no Brasil quanto no exterior. Fiz perguntas, busquei mentoria e aprendi com as experiências delas. Entendi que o sucesso nesta área era tanto sobre quem você conhece e como aprende com eles quanto sobre as habilidades que você possui.

Pouco a pouco, todas essas ações começaram a dar resultado. Minha confiança cresceu, não por uma revelação repentina, mas por uma série de pequenas vitórias—cada uma provando para mim mesmo que eu não era apenas bom o suficiente, mas que tinha algo único a oferecer. Comecei a ver oportunidades onde antes via obstáculos. Passei a confiar nos meus instintos, a tomar decisões mais ousadas e a assumir papéis que exigiam mais de mim.

O Grande Momento:

Todas essas etapas, todas aquelas noites sem dormir e todas as pequenas vitórias me levaram a este momento—um momento que parecia o ponto culminante de todo o trabalho duro, riscos e determinação implacável que eu investi no último ano.

Me encontrei em uma conferência online no Zoom, diante de uma sala virtual cheia de profissionais de todo o mundo—pessoas de diferentes países, falando diferentes idiomas, cada uma com suas próprias perspectivas e expertise. A pressão era grande; essa era a minha oportunidade de apresentar um sistema de arquitetura completo que eu havia desenvolvido—um sistema que eu começaria a implementar ao longo do próximo ano.

Enquanto olhava para a tela, via os nomes e rostos de pessoas de origens diversas, cada uma com suas próprias experiências e expectativas. Eu sabia que estavam ouvindo atentamente, e a pressão era enorme. Ali estava eu, um desenvolvedor brasileiro, prestes a apresentar minha visão para um público global.

Respirei fundo e comecei minha apresentação, navegando por slides e telas que detalhavam os princípiosfundamentais da arquitetura, seu design modular e sua escalabilidade futura. Estava ciente do ceticismo na sala—uma reação compreensível quando alguém de outro lado do mundo, de uma cultura diferente e com uma língua nativa diferente, propõe um plano para transformar a forma como as coisas são feitas.

Mas não deixei que isso me abalasse. Lembrei de todos os momentos que me prepararam para aquilo: dominar novas tecnologias, praticar meu inglês até que se tornasse natural, e assumir riscos para provar meu valor nos ambientes mais desafiadores. Concentrei-me em transmitir a mensagem de forma clara e confiante, garantindo que cada ponto fosse sustentado por lógica e evidências.

À medida que a apresentação avançava, notei a mudança no engajamento. As pessoas começaram a fazer perguntas, a concordar com a cabeça e a mostrar interesse genuíno. Elas não estavam apenas avaliando minhas ideias; estavam imaginando como poderiam fazer parte desse novo sistema. No final, a discussão não era mais sobre se minha arquitetura funcionaria, mas sobre quão rápido poderíamos começar e quais etapas seriam necessárias para colocá-la em prática.

Ao terminar aquela apresentação, senti uma onda de alívio e orgulho. Não se tratava apenas de convencê-los; tratava-se de provar para mim mesmo que eu pertencia àquela sala—virtual ou não. Apesar das barreiras linguísticas, das diferenças culturais e da distância física, eu havia demonstrado que, com trabalho duro, coragem e confiança, é possível deixar sua marca em qualquer lugar.

Conselhos para Outros Desenvolvedores:

Para todos os desenvolvedores no Brasil que sonham em levar suas habilidades para um palco internacional, quero compartilhar isto: é possível. A jornada pode não ser fácil, e haverá momentos em que você vai questionar a si mesmo, suas habilidades e até sua decisão de seguir esse caminho. Mas lembre-se, a dúvida faz parte do crescimento. Significa que você está entrando em um novo território, se esticando além do que conhece, e é exatamente aí que você precisa estar.

Se há uma coisa que minha experiência me ensinou, é que a confiança é construída, não encontrada. Ela é conquistada por meio da ação, da persistência e da disposição de se expor, mesmo quando é desconfortável. Aqui está o que me ajudou, e que eu acredito que pode ajudar você também:

Trate o aprendizado como uma jornada para a vida toda: Não se limite às tecnologias ou ferramentas que você usa no trabalho. Explore o que está em alta no mercado e não tenha medo de aprender algo novo, mesmo que esteja fora da sua expertise atual. Eu tomei a iniciativa de aprender Next.js, Node.js e MongoDB no meu tempo livre, não porque precisava, mas porque queria estar preparado para oportunidades maiores.
Construa projetos reais, mesmo que sejam não remunerados: Às vezes, você precisa criar suas próprias oportunidades. Eu criei um aplicativo para uma padaria local usando um stack moderno para provar a mim mesmo e aos outros que podia entregar soluções no mundo real. Esse projeto não foi sobre ganhar dinheiro; foi sobre construir confiança e mostrar o que eu poderia fazer.
Invista em suas habilidades de comunicação: O inglês é crucial se você quer entrar em mercados internacionais. Trate isso como qualquer outra habilidade—pratique diariamente, faça aulas se puder e se esforce para usá-lo em ambientes profissionais. Pense nisso como aprender uma nova linguagem de programação que vai desbloquear novas possibilidades para você.
Construa sua marca pessoal: Compartilhe sua jornada. Escreva artigos, crie conteúdo, contribua para projetos open-source e participe de comunidades. Deixe o mundo ver do que você é capaz e se posicione como alguém que está sempre aprendendo e disposto a ajudar os outros a crescer também.
Não espere pela oportunidade perfeita—crie-a: As oportunidades nem sempre baterão à sua porta; às vezes você tem que construir a porta você mesmo. Saia da sua zona de conforto, assuma riscos e esteja aberto a novos desafios, mesmo que pareçam assustadores no início.
Acredite no seu valor: Sua origem, de onde você vem ou a língua que fala nunca devem ser barreiras. Elas fazem parte da sua história única e trazem uma perspectiva nova para a mesa. Acredite no que você tem a oferecer e saiba que suas habilidades e dedicação podem te levar a qualquer lugar.

Lembre-se, o caminho para uma carreira internacional não é uma linha reta. Haverá altos e baixos, curvas e reviravoltas, mas se você se mantiver comprometido com seu crescimento e acreditar em si mesmo, encontrará o seu caminho. Continue aprendendo, continue construindo e continue avançando—porque o mundo precisa do seu talento.

Building Multi-Brand Systems with Next.js and Tailwind Theme

Marcel Scognamiglio — Thu, 07 Mar 2024 14:02:00 +0000

More than debating seniority, what defines for me whether the developer is really "awesome" is knowing if they have been challenged with a bit of everything: from monolithic systems that become a maintenance nightmare to complex solutions that require a team of specialists to be managed.

In one of my current projects, I lead a lean team where we develop custom systems for small businesses, such as cafes, restaurants, and bars. Initially, the idea was simple: one system per customer, like a clone of the system and business rules, but with customized design and features. But we soon realized that this approach was a path to maintenance hell.

The solution for the front: multi-tenant systems with Next.js and Tailwind Theme
We needed a solution that was scalable, flexible, and easy to maintain. That's when we found the perfect combination: Next.js and Tailwind and their theme features.

With Next.js, we can create robust and high-performance web applications with ease. And Tailwind allows us to define custom themes based on Tailwind CSS, making it easier to create multi-brand interfaces.

Environment variables to the rescue

To make the front-end dynamic, we use environment variables like BRAND. This variable controls which "instance" the front-end needs to build, with specific images, texts, and CSS for each client.

The next step: 100% headless multi-tenant architecture

In the future, we want to take this solution to the next level with a 100% headless multi-tenant architecture. This means that all system content and settings will be stored in the backend, and the front-end will just be an interface to consume this data.

Why is this the best solution?

Scalability: We can easily add new clients without needing to modify the front-end code.
Flexibility: We can customize each system individually, based on the client's needs.
Maintenance: It is much easier to maintain a single system than multiple different systems.

Conclusion:

The combination of Next.js, Tailwind, and environment variables allows us to create scalable, flexible, and easy-to-maintain multi-brand frontends. If you are looking for a solution to build custom systems for your clients, this is the ideal option!

Share your experience in the comments! Have you used Next.js and Tailwind in your projects?

Construindo sistemas multi-marca com Next.js e Tailwind Theme

Marcel Scognamiglio — Thu, 07 Mar 2024 13:56:46 +0000

Mais do que debater senioridade, o que define para mim se a pessoa desenvolvedora é "braba" mesmo é saber se este já foi desafiado de tudo um pouco: desde sistemas monolíticos que se tornam um pesadelo de manutenção até soluções complexas que exigem uma equipe de especialistas para serem gerenciadas.

Em um dos meus projetos atuais, lidero um time enxuto onde desenvolvemos sistemas sob medida para pequenas empresas, como cafés, restaurantes e bares. No início, a ideia era simples: um sistema por cliente, como um clone do sistema e regras de negócio, mas com design e funcionalidades personalizadas. Mas logo percebemos que essa abordagem era um caminho para o inferno da manutenção.

A solução para o front: sistemas multi-inquilinos com Next.js e Tailwind Theme

Precisávamos de uma solução que fosse escalável, flexível e fácil de manter. Foi aí que encontramos a combinação perfeita: Next.js e Tailwind e suas funções de tema.

Com Next.js, podemos criar aplicações web robustas e performáticas com facilidade. E o Tailwind nos permite definir temas personalizados com base no Tailwind CSS, facilitando a criação de interfaces multi-marca.

Variáveis de ambiente para o resgate

Para tornar o front-end dinâmico, utilizamos variáveis de ambiente como BRAND. Essa variável controla qual "instância" o front-end precisa montar, com imagens, textos e CSS específicos para cada cliente.

A próxima parada: arquitetura multi-inquilino 100% headless

No futuro, queremos levar essa solução para o próximo nível com uma arquitetura multi-inquilino 100% headless. Isso significa que todo o conteúdo e configurações do sistema serão armazenados no backend, e o front-end será apenas uma interface para consumir esses dados.

Por que essa é a melhor solução?

Escalabilidade: Podemos adicionar novos clientes com facilidade, sem precisar modificar o código do front-end.
Flexibilidade: Podemos personalizar cada sistema individualmente, com base nas necessidades do cliente.
Manutenção: É muito mais fácil manter um único sistema do que vários sistemas diferentes.

Conclusão:

A combinação de Next.js, Tailwind e variáveis de ambiente nos permite criar frontend multi-marca escaláveis, flexíveis e fáceis de manter. Se você está buscando uma solução para construir sistemas sob medida para seus clientes, essa é a opção ideal!

Compartilhe sua experiência nos comentários! Você já utilizou Next.js e Tailwind em seus projetos?

Revolutionizing Front-End Development: An In-Depth Look at React 19's Compiler

Marcel Scognamiglio — Tue, 05 Mar 2024 13:47:09 +0000

Hello! So, you want to know more about the React Compiler? There's a reason for that: according to Meta's developers, it's already compiling the entire front-end of one of the world's largest social networks, instagram.com. The React team is getting ready to release their own compiler to the world in React 19, which is expected to be announced in May, and, man, it's going to shake up the development world.

The Problem of Re-Rendering in React

It all started with re-rendering. Let me explain: you know when you change something in your React app and it decides to update more things than it should? That happens, right? You're not alone. Since the beginning, the React folks have been suggesting using things like useMemo, useCallback, and memo to control this. But, let's face it, it can become a mess and is a lot of work to maintain and optimize – again, you're not alone in this...

The Problem of Lacking a Compiler

Without the React Compiler, we developers face the challenge of manually having to check and refactor things to improve the performance of React applications, a complex task due to the dynamic nature and loose rules of JavaScript. That's why the React Compiler emerges as an innovative solution: it aims to optimize the code by modeling the rules of JavaScript and React, ensuring that components are idempotent* (i.e., they always return the same result if the inputs are the same) and do not change props or states. It attempts to compile code safely, adapting to developer practices and skipping compilation when necessary to avoid side effects.

What Is This React Compiler?

The idea of the React Compiler is like: "Leave it to me! I'll take care of this optimization for you." It takes your code and gives it a good tune-up to avoid those unnecessary re-renders. It's like automating the entire memoization process in an elegant and precise way, and anyone who has automated knows: good automation is from machine (writer) to machine (reader) so we can focus on overseeing the process. How cool is that?

Why Is This Cool?

Performance: Fewer unnecessary updates mean a faster and more responsive app.
Clean Code: You can focus on writing your code without worrying about complicated optimizations.
Improved Dev Life: Less headache with performance means more time to create amazing things.

Preparing for the React Compiler

Want to get in on this? Activate Strict Mode and adjust your React ESLint. This way, you'll already be aligned with best practices and ready for when the Compiler is available to everyone.

So, do you want to see the Compiler in action? Check out the presentation that the React team made. They even used the Compiler on Instagram, so we already have an idea of how this can be a game-changer.

*In mathematics and computer science, idempotence is the property that some operations have of being able to be applied multiple times without changing the result's value after the initial application.

React 19: um compilador para chamar de seu – entenda

Marcel Scognamiglio — Wed, 28 Feb 2024 13:30:31 +0000

Olá! Então, você quer saber mais sobre React Compiler? Tem motivo: essa parada já está, segundo os devs do Meta, compilando todo o front-end de uma das maiores redes sociais do mundo, o instagram.com. A equipe do React está se preparando para lançar seu próprio compilador para o mundo no React 19, que deve ser anunciado em maio, e, cara, isso vai chacoalhar o mundo do desenvolvimento.

O Problema do Re-Render no React

Tudo surgiu no re-render. Explico: sabe quando você muda alguma coisa no seu app React e ele decide atualizar mais coisas do que deveria? Isso acontece, né? Você não está só. Desde o começo, a galera do React vem sugerindo usar coisas como useMemo, useCallback, e memo para controlar isso. Mas, convenhamos, isso pode virar uma bagunça e dá um trabalhão para manter e otimizar – de novo, você não está sozinho nessa...

O Problema da falta de um compiler

Sem o React Compiler, nós desenvolvedores enfrentamos o desafio de manualmente ter que checar e refatorar coisas para melhorar a performance dos aplicativos React, uma tarefa complexa devido à natureza dinâmica e às regras frouxas do JavaScript. É por isso que o React Compiler surge como uma solução inovadora: ele deve otimizar o código ao modelar as regras do JavaScript e do React, garantindo que os componentes sejam idempotentes* (ou seja, sempre retornam o mesmo resultado se os inputs forem os mesmos) e não mudem props ou estados. Ele tenta compilar código de forma segura, adaptando-se às práticas do desenvolvedor e pulando a compilação quando necessário para evitar efeitos colaterais.

O Que é Esse React Compiler?

A ideia do React Compiler é tipo: "Deixa comigo! Eu cuido dessa otimização pra você". Ele pega seu código e dá uma boa tunada para evitar esses re-renders desnecessários. É como se ele automatizasse todo o processo de memoização de forma elegante e precisa, e quem já automatizou sabe: automatização boa é de máquina (escritora) para máquina (leitora) a gente pode focar em supervisionar o process. Quão daora é isso?

Por Que Isso é Daora?

Performance: Menos atualizações desnecessárias significam um app mais rápido e responsivo.
Código Limpo: Você pode focar em escrever seu código sem se preocupar com otimizações complicadas.
Vida de Dev Melhorada: Menos dor de cabeça com performance significa mais tempo para criar coisas incríveis.

Se Preparando para o React Compiler

Quer entrar nessa onda? Ative o Modo Estrito e ajuste o ESLint do React. Assim, você já vai estar alinhado com as melhores práticas e pronto para quando o Compiler estiver disponível para todos.

E aí, quer ver o Compiler em ação? Dá uma olhada na apresentação que a equipe do React fez. Eles até usaram o Compiler no Instagram, então já temos uma ideia de como isso pode ser um game-changer.

*Em matemática e ciência da computação, a idempotência é a propriedade que algumas operações têm de poderem ser aplicadas várias vezes sem que o valor do resultado se altere após a aplicação inicial.

Manifesto do Desenvolvedor Punk: A Arte de Aprender Fazendo

Marcel Scognamiglio — Wed, 14 Feb 2024 15:19:34 +0000

Olá, sou Marcel, um desenvolvedor punk, e quero compartilhar com vocês a essência de nossa filosofia. Este manifesto é para todos que desejam quebrar as correntes convencionais e trilhar seu próprio caminho na tecnologia.

1. Autonomia É a Chave

Seja Seu Próprio Guia: Se você está esperando alguém te mostrar o caminho, você está no manifesto errado. Aqui, nós traçamos nossas próprias rotas com a ajuda, nada de “coach”, de outros devs punks.
Esqueça o Caminho Tradicional: Não estamos limitados por diplomas ou currículos estruturados. A verdadeira educação vem da exploração individual - sua experência é seu DNA Dev: única é intransferível.

2. Aprendizado Prático Acima de Tudo

É impossível aprender tudo. Assim como aceitar que tudo que vive (inclusive você) vai morrer um dia, admitir que o que sempre haverá mais assuntos os quais você é um total ignorante do que aqueles pouquíssimos que você sabe, é um caminho na direção certa.
"Aprenda Fazendo" Não é Clichê: Livros, aulas e professores são úteis, mas nada supera a experiência de “sujar” suas mãos no código e construir algo real para o mundo real.
Projetos Reais / Pessoais São Seus Melhores Professores: Cada linha de código, cada bug, cada solução é uma aula prática – ouse errar, dizer que não sabe algo e aprender de verdade em um mundo onde quase todo mundo quer parecer “especialista”.

3. Desafiando o Status Quo

FAANG Não Define o Sucesso: Trabalhar em gigantes da tecnologia pode ser um objetivo, mas não é o único caminho para a excelência. Ouse encontrar felicidade enquanto trabalha. Muita gente, apesar de trabalhar em uma big tech, não é.
A Síndrome do Impostor é uma Farsa: Não permita que a imagem do "programador perfeito”, o “10x” minem sua confiança. A excelência vem em muitas formas – e pode vir do jeito que você quiser.

4. Habilidades Que Vão Além do Código

Comunicação é Fundamental: Saber se expressar e entender os outros é tão crucial quanto entender uma nova linguagem de programação.
Seja seu próprio mestre: Organizar projetos e tempo é uma arte que todo Dev Punk precisa dominar.

5. Aprendizado Seletivo e Prático

Priorize o Aprendizado Útil: Não se perca em complexidades sem aplicação prática. Se não ajuda na vida real, pode esperar.
Flexibilidade e Adaptabilidade: AI, Major Release? O mundo da tecnologia está sempre mudando. Esteja pronto para aprender e adaptar-se continuamente.

6. Autogestão e a Arte de Transformar Código em Sucesso

Gerencie seus Projetos com Maestria: Aprenda a transformar um simples código em um projeto com começo meio e fim. Evite criar mais um "repositório cemitério".

7. Conclusão: Encontre Seu Próprio Caminho

Seja Autêntico: Respeite seus limites, seja verdadeiro com suas escolhas e seja seu próprio mentor. No final das contas, é isso que nos define como profissionais e, mais importante, como pessoas.

Este manifesto é mais do que palavras; é um convite para viver e respirar tecnologia de uma maneira que faça sentido para você. É uma chamada para ser mais do que um desenvolvedor: ser um Dev Punk. Então, o que você está esperando? Mergulhe de cabeça no desconhecido e descubra o poder do aprendizado prático. Boa jornada!

How to Use WordPress as an Engineer

Marcel Scognamiglio — Tue, 19 Dec 2023 13:48:11 +0000

Engineering is the application of scientific, mathematical, and technological knowledge to the solution of problems and the creation of products and services. In the context of software systems, software engineering is responsible for ensuring that these systems are reliable, secure, integral, and productive.

WordPress is a popular content management system (CMS) used to create websites and blogs. It is a powerful tool that can be used to create websites of any size and complexity. However, WordPress can also be a challenging platform to maintain, especially for those who are not familiar with software engineering best practices.

In this article, we will discuss how to use WordPress in a more reliable, secure, integral, and productive way.

What is a monolith?

A monolith is a software system that is composed of a single unit. This means that all of the system's components, including the source code, data, and infrastructure, are all interconnected.

WordPress is a monolith. The WordPress source code, website data, and hosting infrastructure are all interconnected. This can make it difficult to maintain WordPress, as any change to one component can affect the other components.

Why is WordPress difficult to maintain?

There are several reasons why WordPress is difficult to maintain:

The WordPress source code is complex and can be difficult to understand.
WordPress is updated frequently, and it is important to keep your site up-to-date with the latest versions.
WordPress is a popular platform, and there are many plugins and themes available. It is important to choose high-quality plugins and themes that are compatible with the latest version of WordPress.
How to use WordPress as an engineer

Here are some tips for using WordPress in a more reliable, secure, integral, and productive way:

Use staging environments. Staging environments are copies of your production site that can be used to test changes before implementing them on the production site. This helps to avoid production problems.
Use page builders. Page builders, such as Elementor and Gutenberg, can help you create pages faster and more efficiently. These tools can also help you create more secure and integral pages.
Create and use global components. Global components are blocks of code that can be reused on multiple pages. This can help to reduce the size of your source code and improve productivity.
Make daily automatic backups. Automatic backups are essential to protect your site from data loss.
Have a software engineering methodology for handling tasks. A software engineering methodology will help you manage your site's maintenance tasks effectively.
Do QA frequently. QA (Quality Assurance) is essential to ensure that your site is reliable and secure.
Adopt a continuous CI/CD approach. CI/CD (Continuous Integration/Continuous Delivery) is an approach to software delivery that helps to ensure that changes to code are delivered in a safe and reliable way.
Conclusion

WordPress is a powerful platform that can be used to create websites of any size and complexity. However, it is important to use WordPress in a way that follows software engineering best practices. By following the tips in this article, you can help to ensure that your site is reliable, secure, integral, and productive.

The experience of using WordPress as an engineer can be a valuable one. By facing the challenges of maintaining a monolith, you will learn a lot about software engineering. This experience will be useful to you in future projects, whether you are a software engineer or a system administrator.

Here are some additional tips for using WordPress as an engineer:

Use a version control system (VCS) to track changes to your code. This will make it easier to roll back changes if something goes wrong.
Write unit tests for your code. Unit tests help to ensure that your code is working as expected.
Use a code review process to review changes to your code before they are implemented. This can help to catch errors and improve the quality of your code.
By following these tips, you can help to ensure that your WordPress sites are reliable, secure, integral, and productive.