DEV Community: Kaic Bento

I turned my personal Windows setup script into a public tool - and it’s now open source

Kaic Bento — Thu, 11 Dec 2025 19:33:11 +0000

Every time I formatted my Windows machine, the same ritual repeated: install the same apps, tweak the same settings, remove the same bloatware, fix the same defaults. Hours have gone by on tasks that should take minutes.

So I built a script.
Then I rebuilt the script.
Then I automated everything.
Then I thought: why is this useful only to me?

That was the beginning of Windows Post-Install. Since its release this week, the project has gained over 10,000 visits and a growing community of over 190 stars. The entire project is now public, free, and open source.

👉 Try the tool instantly: Win Post Install

What it does (in plain terms)

👉 Generate your Windows setup script here: Win Post Install

It’s a web-based tool that lets you generate a complete Windows setup script without installing anything or opening a terminal.

You select what you want:

100+ pre-curated applications (browsers, dev tools, productivity, media, gaming…)
80+ system configurations (privacy, performance, UI tweaks, QoL settings)
optional cleanup tools (remove bloatware the safe way)

Click Generate, and the tool spits out a ready-to-run script.

No manual winget lookups.
No regedit hunting.
No PowerShell copy/paste.
Just a reproducible setup in one file.

🎉 And has a Dark Mode!

How it works (quick technical overview)

Under the hood, it's a simple React + TypeScript application built with:

React for the UI
Vite for bundling
TailwindCSS for styling
JSON-based catalogs for apps and system configs
winget + PowerShell + Windows built-ins for the final script
Everything runs entirely in your browser — zero backend.

That means anyone can clone, fork, extend, and ship their own version.

Why I made it open source

Because the tool is bigger than my personal workflow.

The catalog of applications and configurations is where the project shines, and that’s precisely the part the community can help evolve. Envision yourself as a “catalog curator,” expanding our tool selection. Are you passionate about user experience? Become a “UI/UX designer” and refine the look and feel. Love languages? Serve as a “localization champ” and help translate for a global audience. Do you have a knack for optimization? Join as a “performance tuner” and optimize performance and responsiveness.

There’s significant room to grow, and I want contributors to take ownership of different parts of the tool.

Where contributors can help right now

Ideal first contributions, ordered by the level of effort and impact:

Add new software entries to the catalog. This is a straightforward task for newcomers to get acquainted with the project.
Create new configuration presets that other users can adopt to enhance their experience.
Suggest new “power user” Windows tweaks. This requires some familiarity with Windows, but can significantly improve usability.
Improve accessibility (ARIA, focus states) to ensure the tool is usable for everyone, with a highly impactful impact.
Enhance documentation with clear instructions and examples to aid user understanding and engagement.
Improve the script generation logic to offer significant performance and functionality benefits.
Add tests (unit and end-to-end) to ensure reliability and uncover potential issues.

If you prefer pragmatic tools that solve real problems, this is a good place to start.

Source Code & Contributing

Repo
Contribution guide

If you want to help improve a tool that thousands of people already find useful, jump in.
Open an issue, propose a feature, or start with a small PR.

This started as something for me.
Now it’s something for everyone.

👉 Use it now: https://kaic.me/win-post-install/

Generate your Windows setup script in seconds — no installs, no terminal, no friction.

If the tool saves you time, share it, star the repo, or tell me what you want next. Let’s build the ultimate Windows setup generator together.

Você não está mais codando só: o desenvolvimento na era dos code agents

Kaic Bento — Sun, 30 Mar 2025 09:08:09 +0000

Você se senta na frente do computador, café na mão. Não abre sua IDE. Só digita:
"MCP, me de três opções de arquitetura pro novo sistema de billing."

Cinco minutos depois, você está analisando os trade-offs entre microservices, event-driven e um monolito com filas — com configs de CI e planos de testes inclusos.

Bem-vindo à sua nova rotina matinal.

Atualmente, todo dia parece surgir um novo agente de codificação (code agent) (que não é não o James Bond). Se você rolar o feed do Twitter ou abrir o GitHub, vai ver vários devs usando agentes pra corrigir bugs, abrir PRs, escrever testes e até fazer deploy — com pouquíssima intervenção humana. A frase "é só rodar o prompt" virou uma estratégia real de desenvolvimento (quase um mantra).

Mas no meio de toda essa empolgação, vale parar pra pensar: o que isso muda, de fato, no nosso dia a dia como desenvolvedores? A indústria de tech vive nos bombardeando com buzzwords que prometem revoluções — e quase nunca entregam. Dessa vez, no entanto, a chegada de ferramentas como o GitHub Copilot marca uma mudança real na forma como desenvolvemos software. Estamos saindo do modelo de dev “linha por linha” pra um novo fluxo mais colaborativo, onde criamos em parceria com a máquina. Não é hype: é transformação de verdade.

Do que estamos falando, afinal? (LLMs, MCPs e Code Agents)

Antes de ir mais fundo, vale alinhar alguns termos.

LLMs (Modelos de Linguagem de Grande Escala) são o ponto de partida. Modelos como o GPT-4, Claude e Gemini foram treinados com quantidades absurdas de texto e código. Eles conseguem explicar, raciocinar e dar respostas técnicas muito boas — até para perguntas mais "cabeludas".

Mas aqui vai um ponto-chave: LLMs sozinhos não constroem software.

Eles não entendem seu código. Não mantêm contexto a longo prazo. Não testam, refatoram ou fazem deploy. Eles só preveem o próximo token com base em probabilidade. E só.

Claro, eles podem gerar uma função ou um arquivo de config aqui e outro ali. Mas sem memória, integração com ferramentas e noção do que fizeram minutos atrás, eles não dão conta de tarefas reais de desenvolvimento.

Pra construir software de verdade, é necessário estrutura, objetivos claros, ferramentas que executem em conjunto, coordenação entre tarefas, memória pra acompanhar o progresso e mecanismos de feedback pra saber se algo funcionou — basicamente o que todo dev precisa no dia a dia.

LLMs são o cérebro. Mas cérebro sozinho não constrói app — precisa de mãos, ferramentas e um plano.

MCPs – Plataformas de Código com Múltiplos Agentes - é aqui onde a coisa começa a ficar interessante. Em vez de depender de um único LLM pra fazer tudo, você monta um time de agentes especializados. Um é bom em debugar, outro em testar, outro em planejar arquitetura — e talvez um que só escreve documentação (o verdadeiro herói, sejamos sinceros).

É como ter seu squad de devs incansáveis, ultra rápidos e que já leram todo repositório do GitHub, todas as threads do StackOverflow e todas as RFCs que você ignorou nos últimos anos — e que nunca cansam, se distraem ou pedem café.

A Anthropic foi uma das primeiras a formalizar esse padrão/protocolo, mostrando como múltiplos agentes podem colaborar para objetivo um comum. Hoje, ferramentas como AutoDev, Devika, e DSPy estão colocando essa ideia em prática.

LLMs são o cérebro. Mas para construir software de verdade, você precisa de mais: ferramentas, coordenação e orientação humana.

Quer criar um CRUD do zero? Você descreve o que quer, o agente que planeja quebra isso em tarefas, o executor escreve o código, o testador valida tudo e o revisor te dá feedback — em questão de minutos.

Não é só sobre automação. É sobre coordenação — e é isso que torna os LLMs realmente úteis em fluxos de trabalho mais complexos.

E aí entram os Code Agents — ferramentas autônomas baseadas em LLMs que executam tarefas completas. Você dá uma missão tipo “adicione autenticação nessa API” e eles planejam, codam, testam e às vezes até abrem o pull request por você.

Já estamos vendo isso acontecer em ferramentas como:

Claude’s Code Interpreter que consegue raciocinar sobre tarefas complexas, editar múltiplos arquivos e ainda explicar tudo passo a passo.

GitHub Copilot que começou como um autocomplete esperto e agora tem o Copilot Workspace — um assistente de planejamento e codificação completo, que te guia por problemas e soluções.

Cursor a IDE com IA integrada, onde você conversa com seu repositório e pede pra ele refatorar, gerar código ou debugar — tudo com contexto.

Esses agentes não entregam só snippets — eles ajudam você a construir. Você para de escrever tudo na unha. Em vez disso, descreve o objetivo, orienta o processo e revisa o resultado.

Você não está mais só programando. Você tá liderando um time (pequeno e incansável).

A Nova Manhã do Dev

Você não começa mais o dia abrindo o seu IDE — você pede pro seu MCP explorar algumas opções de arquitetura pra aquela nova feature. Ele gera o código, roda os testes e apresenta os trade-offs.

Você escolhe a melhor, dá feedback de alto nível, e deixa seus agentes configurarem o projeto, prepararem o CI, escreverem os testes e até esboçarem a documentação.

Seu papel? Guiar, refinar e garantir que tudo faz sentido pro produto e pro domínio — e claro, revisar o código esquisito da IA também (lol).

Ferramentas como AutoDev, GPT Engineer e Claude Code já permitem que você descreva um sistema e veja ele ganhar vida — com código real, testes e configs.

Essa virada muda a forma como a gente trabalha:

Menos digitação, mais "promptação"
Menos execução linear, mais orquestração
Menos apagar incêndio (um caloroso abraço a todos os bombeiros de plantão), mais design
Menos trabalho solo, mais colaboração com agentes

Mas esse novo fluxo também exige novas skills:

Prompting: não é só pedir, é saber direcionar
LLMOps: saber debugar, isolar, controlar comportamento
Pensamento sistêmico: menos sintaxe, mais estratégia

A Revolução Que Já Aconteceu

Isso não é só papo de futuro. Já está acontecendo — e rápido.

Mais de 1,3 milhão de devs já usam o GitHub Copilot, que ajuda com boilerplate, sugere funções inteiras e economiza horas em tarefas repetitivas. O Copilot Workspace agora vai além: ele planeja, quebra problemas em etapas e orienta a implementação.

O Claude Code lê sua base inteira, explica o que tá acontecendo e ajuda a refatorar — com explicações claras, quase como um pair programming. Já o Devika analisa seu repositório, pensa numa solução, escreve o código e abre um pull request, coordenando múltiplos LLMs no processo.

O Cursor permite conversar direto com seu código dentro do IDE. Enquanto isso, ferramentas como o AutoDev e o DSPy orquestram múltiplos agentes agindo em sincronia: um planeja, outro implementa, outro testa.

Está nascendo um padrão claro aqui. E um paper recente capturou isso bem: a engenharia de software está migrando da geração de código pra coordenação de agentes. Não se trata mais só de digitar menos — mas de usar sistemas autônomos que ajudam a planejar, construir e manter software de verdade.

Essa mudança não é sobre substituir devs. É sobre dar mais alavancagem pra gente.

Não É Mágica. Pelo Menos, Ainda Não.

LLMs não têm memória persistente. Elas alucinam constantemente, perdem o contexto e se atrapalham em bases grandes de código.

Elas são ótimos pra gerar uma função. Mas integrar essa função em um sistema real — com código legado, efeitos colaterais e edge cases — é outro jogo.

Mesmo quando o código parece limpo, é difícil saber se está seguro, correto ou fácil de manter sem revisar tudo a fundo.

E ainda há outros riscos: dependência excessiva, acesso a shell, e aquela preguiça que vai te fazendo esquecer como pensar nos problemas sozinho.

Sim, as ferramentas são poderosas. Mas ainda precisam do nosso julgamento ao usá-las.

Não é sobre tirar a mão do volante — é sobre aprender a dirigir diferente.

Quando o "Vibbing" Substitui o Ententimento

Quando o vibe coding domina: o dev entra em transe enquanto a IA carrega o piano (bugs inclusos).

Ou: Por que “só mandar o prompt” nem sempre resolve.

Tá rolando um mindset novo chamado "vibe coding" (ref e ref). A ideia é simples: você descreve o que quer, o LLM cospe um código, e você... faz deploy. Você não entende o que tá acontecendo por baixo dos panos — mas pelo menos roda, né?

E sim, isso é poderoso. Principalmente pra iniciantes, não-devs ou quem tá automatizando rapidinho alguma tarefa.

Mas pra quem trabalha com software profissionalmente? Aí começa a ficar perigoso.

Se você para de entender o código que tá subindo — se não consegue explicar a lógica, resolver um bug ou perceber um erro sutil — você não está mais construindo software. Está só cruzando os dedos esperando que a IA tenha acertado tudo feito mágica.

Vamos dar um exemplo: um dev júnior usou o GPT pra gerar um endpoint de "delete user". Parecia ok. Mas ele deletava todos os usuários do banco — porque não validava o user_id. A IA só fez o que foi pedido. O prompt não cobriu o edge-case.

Outro caso: um dev usou o Copilot pra “proteger” uma API, adicionando checagem de JWT mas esqueceu de verificar a assinatura. Parecia tudo seguro. Ele rodou em staging, mas quando rodou em produção, quebrou e expôs dados sensíveis.

Aqui tá o que o Claude Code gerou quando pediram pra “Adicionar autenticação via JWT nesse endpoint”:

app.post('/login', async (req, res) => { const token = jwt.sign({ userId: user.id }, process.env.JWT_SECRET, { expiresIn: '1h' }); res.json({ token }); });

Não é ruim. Mas ele esqueceu de verificar as assinaturas nos requests recebidos. É aí que você, dev, entra.

Esse é o risco de priorizar velocidade e "vibbing" acima de entendimento.

No longo prazo, isso pode dar ruim:

Código podre — agentes geram código que ninguém entende ou quer manter
Debugar vira arqueologia — tentando entender decisões bizarras da IA
Riscos de segurança — só porque “funciona” não quer dizer que está seguro
Erosão de habilidade — você vai perdendo o faro técnico por não pensar mais nos problemas

Code agents são úteis, mas precisam ser tratados como devs júnior: rápidos, incansáveis — mas que precisam de acompanhamento.

Se você não sabe programar, não sabe revisar código, e se não consegue revisar o que a máquina entrega, você só está tendo esperança e torcendo para tudo passar no CI.

Mas aqui vai o plot twist: enquanto tem gente preocupada com a IA tirando empregos, eu vejo o surgimento de dois novos nichos de devs:

De um lado, iniciantes e não-devs criando produtos novos com Claude, Copilot, etc.
Do outro, cresce a demanda por devs experientes que entram depois — pra escalar, manter, revisar e dar segurança a esse código gerado dessa forma.

Ao invés de acabar com empregos, a IA tá reformulando o mercado — e criando mais trabalho pra quem sabe ler nas entrelinhas do que ela produz.

Vamos parar de "vibear" código que vai explodir em produção.

Eu mesmo, 2025

Abraçando a Máquina Sem Perder a Nossa Essência

Não é homem contra máquina — é homem com máquina. O nosso novo stack de desenvolvimento se constrói com confiança, ferramentas e parceria.

Num post anterior, escrevi que deveríamos ser amigos das nossas ferramentas. Isso continua valendo mais do que nunca. LLMs são poderosas, mas ainda são só isso: ferramentas.

O melhor dev dessa nova era não vai ser o que escreve mais código. Vai ser o que transforma uma ideia vaga num plano claro, que um agente consegue executar. É quem sabe revisar, adaptar e melhorar o que a máquina devolve.

Quer ficar bom nisso? Comece pequeno (mas comece!).

Teste o Claude Code numa feature que você já conhece bem. Refatore uma função, corrija um bug, escreva testes — depois revise tudo como faria com um dev júnior.

Use o GitHub Copilot como dupla, não como guru. Deixe ele sugerir, mas decida o que faz sentido manter.

Explore seu repo com o Cursor. Faça perguntas, tente uma refatoração, quebre tudo de propósito e veja como ele se vira.

Rode seus LLMs localmente com Ollama e Docker. Este vídeo, feito pelo meu amigo Erick Wendel (com quem já tive o prazer de trabalhar), mostra como rodar modelos; como DeepSeek e Gemma; local ou na nuvem — ótimo pra quem quer entender o que acontece por baixo dos panos.

Esse é nosso novo workflow: digitar menos, pensar mais. Menos força bruta, mais design. Mais colaboração e delegação pra máquina.

E esse artigo aqui? Foi escrito com ajuda de alguns LLMs. Eles me ajudaram a buscar papers, organizar ideias e ajustar frases ruins. Mas todas as decisões fui eu quem tomou — eles só tornaram o processo mais rápido.

E você?

Tá liderando seus agentes — ou só "vibbing" no meio do caos?

Quero muito saber quais ferramentas você já testou, o que funcionou (ou não) e como você está se adaptando a elas.

Quais ferramentas você está usando? Como você tá evoluindo com elas?

Deixa um comentário, responde aí ou me chama (estou em kaic.me).

Bora continuar construindo juntos esse novo jeito de desenvolver.

Recursos & Referências

Quer mergulhar mais fundo? Separei ferramentas, demos e leituras essenciais pra explorar:

📚 Artigos

🛠 Ferramentas pra explorar

You’re Not Coding Alone Anymore: Coding in the Age of Agents

Kaic Bento — Sat, 29 Mar 2025 04:36:55 +0000

You sit down at your desk, coffee in hand. You don’t open your IDE. You type a message: “MCP, draft three architecture options for the new billing feature.”

Five minutes later, you’re reviewing tradeoffs between microservices, event-driven, and monolith-plus-queues — with CI configs and test plans included.

Welcome to your new morning routine.

It seems everyone now has a software agent (not James Bond). Scroll through Twitter or GitHub, and you’ll see examples of developers using agents to fix bugs, open PRs, write tests, and deploy code with minimal human input. The mantra “just prompt it” is evolving into a powerful software development strategy.

Yet, among this excitement, we must ask: What does this truly mean for our daily work as developers? The tech industry often inundates us with buzzwords that promise revolutionary changes but rarely deliver. This time, however, the emergence of tools like GitHub Copilot signals a profound shift in software development. We are moving toward a collaborative landscape where we partner with machines to create rather than diligently writing code ourselves. This transformation is not just a trend; it’s a game-changer!

What Are We Talking About? (LLMs, MCPs, and Code Agents)

Let’s get the terms straight before diving deeper.

LLMs (Large Language Models) are where it all starts. Models like GPT-4, Claude, and Gemini are trained on absurd amounts of text and code. They can reason, explain, and spit out surprisingly good answers to tricky technical questions.

But here’s the thing: LLMs by themselves don’t build software.

They don’t understand your codebase. They don’t hold long-term context. They don’t test, refactor, or ship. They predict the next token based on probability. That’s it.

Sure, they can generate a function here or a config file there. But without memory, tooling, or a sense of what they did five minutes ago, they can’t handle real-world development tasks end to end.

To build software, you need structure. You need goals, tools with execution rights, orchestration across tasks, memory to keep track of progress, and feedback loops to know if something worked or failed—basically, what every human developer needs.

LLMs are the brain. But brains alone don’t build apps — they need hands, tools, and a plan.

MCPs – Multi-Agent Code Platforms are where things get interesting. Instead of relying on a single LLM to do everything, you spin up a team of specialized agents. One’s good at debugging, another handles testing, another plans the architecture, and maybe one writes docs all day (the real hero of this squad, honestly).

It’s like having your squad of tireless, lightning-fast devs who’ve read every GitHub repo, Stack Overflow thread, and RFC in existence — and who never get tired, distracted, or ask for a coffee break.

Anthropic was one of the first to formalize this pattern, showing how multiple agents can work together toward a goal. Now, tools like AutoDev, Devika, and DSPy are implementing that idea.

LLMs are the brain. But to build real software, you need more: tools, coordination, and human guidance.

Want to build a CRUD app from scratch? You describe it, and the planner agent breaks it into tasks, the implementer writes the code, the tester runs validations, and the reviewer gives you feedback — all in minutes.

It’s not just about automation. It’s about coordination, and it’s the key to making LLMs useful in complex dev workflows.

And then we’ve got Code Agents — autonomous tools built on LLMs that can get things done. You give them a task like “add authentication to this API,” and they’ll plan, write the code, run some tests, and sometimes even open a pull request for you.

We’re already seeing this in tools like:

Claude’s Code Interpreter can reason through complex tasks, make edits across files, and explain the changes step by step.

GitHub Copilot started as a smart autocomplete but now offers Copilot Workspace, a full planning and coding assistant that walks you through issues and solutions.

Cursor (the AI-powered IDE), where you can talk to your repo and ask it to refactor, generate code, or debug with context awareness.

These agents don’t just give you snippets — they help you build. You stop writing every line by hand. Instead, you describe the goal, guide the steps, and review the results.

You’re not just coding anymore. You’re leading a tiny (and tireless) team.

A Developer's New Day

You don’t start your day opening your IDE anymore — you ask your MCP to explore a few architecture options for that new feature. It spins up code, runs tests, and lays out the tradeoffs.
You pick the best one, give high-level feedback, and let your agents scaffold the project, set up CI, write tests, and even draft the docs.
Your job? Guide, refine, and make sure everything makes sense for the product and the domain—and yeah, review the AI’s slop code, too (lol).

Tools like AutoDev, GPT Engineer, and Claude Code already let you describe a system and watch it come to life — with actual code, tests, and configs.

This shift changes how we work:

Less typing, more prompting
Less linear execution, more orchestration
Less firefighting, more design
Less solo work, more agent collaboration

But this new workflow needs new skills:

Prompting: not just asking, but steering
LLMOps: debugging, sandboxing, managing behavior
System thinking: less syntax, more strategy

The Revolution That Already Happened

This isn’t just future hype; it’s already happening quickly.

Over 1.3 million developers use GitHub Copilot, which assists with boilerplate code, suggests functions, and saves time on repetitive tasks. Copilot Workspace now includes planning capabilities, such as breaking down issues and guiding implementations.

Claude Code can read and explain entire codebases, aiding in refactoring with detailed explanations resembling pair programming. Devika analyzes repositories, develops solutions, writes code, and creates pull requests, coordinating multiple language models for decision-making.

Cursor allows direct chatting with your code in your IDE, while tools like AutoDev and DSPy enable synchronized workflows with specific roles for planning, implementation, and testing. This shift in software engineering is moving towards agent coordination, focusing on autonomous systems that assist in planning, building, and maintaining software.

A clear pattern is emerging, and a recent survey paper captures it well: software engineering is shifting from code generation to agent coordination. It’s no longer just about typing less while coding; it’s about utilizing autonomous systems that assist in planning, building, and maintaining real software.

This shift isn’t about replacing developers; it’s about providing us with greater leverage.

Not Magic. Not Yet.

LLMs don’t have persistent memory. They hallucinate, lose track of context, and get confused in large codebases.

They’re great at generating a function. But integrating that function into a real system — with legacy databases, side effects, and edge cases — is a different game.

Even when the code looks clean, it’s hard to tell if it’s safe, correct, or maintainable without a deep review.

There’s also risk: overdependence, potential shell access, and slowly forgetting to think through problems yourself.

So yeah, the tools are powerful, but we still need human judgment. It’s not hands-off—it’s just hands-different.

When Vibes Replace Understanding

When vibe coding takes over: the dev transcends into flow while the AI does the heavy lifting (bugs included).
When vibe coding takes over: the dev transcends into flow while the AI does the heavy lifting (bugs included).

Or: Why “just prompt it” isn’t always enough.

There’s this new mindset floating around called “vibe coding.” (ref and ref). The idea is simple: describe what you want, the LLM spits some code, and you... ship it. You don’t understand what’s happening under the hood — but hey, the thing runs, right?

And yeah, that’s powerful, especially for beginners, non-devs, or people trying to automate something quickly.

But for professional developers? Here is where things get dangerous.

If you stop understanding the code you’re deploying — if you can’t explain the logic, reason through a bug, or catch a subtle mistake — then you’re no longer building software. You’re just crossing your fingers and hoping the AI knows what it’s doing.

Real example? A junior dev used GPT to generate a “delete user” endpoint. Looked fine. Except it deleted all users from the database because it didn’t validate the user_id. The AI did what it was told — the prompt didn’t cover the edge case.

Another: a dev used Copilot to “secure” an API, adding a JWT check but forgetting to verify the signature. It gave a false sense of security. It worked in staging, broke production, and exposed data.

Here’s what Claude Code generated he asked it to “Add JWT-based auth to this API endpoint”:

app.post('/login', async (req, res) => {
const token = jwt.sign({ userId: user.id }, process.env.JWT_SECRET, { expiresIn: '1h' });
res.json({ token });
});

It’s not bad, but it forgot to verify the signatures on incoming requests. That’s where you (as a developer) come in.

This is the risk when we optimize for speed and vibes over understanding.

Long-term, this can lead to real issues:

Code rot — agents generate code that nobody fully understands or owns.

Debugging turns into archaeology — digging through AI-generated logic to determine what went wrong.

Security risks explode — because “working” isn’t the same as “safe.”

Skill erosion — you slowly lose your edge as a dev by outsourcing the thinking.

Code agents are beneficial. But they need to be treated like junior developers: fast and tireless but in desperate need of supervision.

If you don’t know how to code, you don’t know how to review code. And if you can’t review what the machine gives you, you’re just shipping hope in a CI pipeline, and This is the risk when we optimize for speed and vibes over understanding.

But here’s the twist: while some worry about AI replacing developers, I see the emergence of two new dev niches. On one side, beginners and non-devs are launching new products and prototypes using tools like Claude and Copilot. On the other hand, there’s a rising demand for experienced developers who can step in later to scale, secure, and maintain this type of code or product generated in this way.

Instead of killing jobs, AI is reshaping the field, creating more work for people who can read between the lines of what the machine produces.

Instead of killing jobs, AI is reshaping the field, creating more work for people who can read between the lines of what the machine produces.

Let’s not vibe our way into production disasters.

Myself, 2025

Embracing the Machine Without Losing Ourselves

_Not man vs. machine — but man with machine. The new dev stack is built on trust, tools, and teamwork.
_

In a previous post, I wrote that we should be friends with our tools. That still holds. LLMs are undoubtedly powerful, but they’re still just tools - just it.

The best developer in this new era will be the one who doesn’t write the most code. It’s the one who can turn a vague idea into a clear, actionable plan that an agent can execute. It’s the one who knows how to review, adapt, and improve what the machine gives back.

Want to get better at this? Start small (but START!)

Try Claude Code for a feature you know well. Refactor a function, fix a bug, or add tests — then review everything it did, as you would with a junior dev.

Use GitHub Copilot like a pair, not a prophet. Let it suggest, but you decide what’s worth keeping.

Explore your repo with Cursor. Ask questions, try a refactor, break stuff on purpose, and see how it handles recovery.

Spin up your LLMs using Ollama and Docker. This video, made by my friend Erick Wendel (whom I had the pleasure of working with), walks through running models like DeepSeek and Gemma locally or in the cloud—super useful if you want to get hands-on and see what’s under the hood.

This will definitely be our workflow from now on: less typing, more thinking, less brute force, more design, collaboration and more machine delegation.

And yeah, this article? It was co-written with the help of a few LLMs. They helped me find papers, structure ideas, and fix clunky phrases. I still made the decisions—they just made it faster.

What about you?

Are you leading your agents — or just vibing through the chaos?

I’d love to hear what tools you’ve tried, what worked (or didn’t), and how you adapt.

What tools are you using? How are you adapting?

Leave a comment, reply, or ping me (you can find me @ kaic.me).

Let’s (always) build something together with this new workflow together!

Resources & References

Want to dive deeper? Here’s a mix of tools, demos, and foundational reads worth exploring:

📚 Articles

🛠 Tools to explore