Além do código: como a IA transformou meu desafio de programação em aprendizado

Como uma metodologia baseada em prática, reflexão e diferentes perspectivas profissionais pode contribuir para a evolução de quem está aprendendo desenvolvimento de software.

Introdução

Aprender programação vai muito além de conhecer uma linguagem ou memorizar comandos.

O verdadeiro desafio está em transformar conhecimento em capacidade de resolver problemas, tomar decisões e construir soluções que possam evoluir.

Durante minha jornada de estudos em Java, especialmente no desenvolvimento do desafio do Jogo Sudoku, busquei uma abordagem diferente: utilizar o projeto não apenas como uma atividade de conclusão, mas como uma oportunidade para desenvolver uma experiência mais próxima da realidade profissional.

Para isso, combinei uma metodologia própria de aprendizado, o uso consciente da Inteligência Artificial e a simulação de diferentes perspectivas presentes em uma equipe de desenvolvimento.

O objetivo deste artigo é compartilhar essa experiência e mostrar como essa abordagem pode ajudar outros estudantes a aproveitarem melhor seus projetos de aprendizagem.

📚 Quando o prazo termina, mas o aprendizado continua

Durante minha jornada de estudos na DIO, participei de um bootcamp focado em desenvolvimento Java.

Como acontece com muitos estudantes, nem sempre conseguimos acompanhar o cronograma inicialmente planejado.

Ao final do período oficial do bootcamp, existia a possibilidade de simplesmente considerar aquela etapa encerrada.

Porém, percebi que o maior valor estava no conhecimento construído durante o processo.

Decidi continuar desenvolvendo os desafios propostos, não apenas com o objetivo de concluir uma formação, mas buscando transformar esses exercícios em projetos que representassem minha evolução técnica.

Essa mudança de perspectiva foi fundamental:

Antes:

"Preciso finalizar o curso."

Depois:

"Preciso aproveitar cada etapa para desenvolver conhecimento e construir algo que demonstre minha evolução."

🧠 Uma metodologia de aprendizado baseada em evolução contínua

Durante esse processo, desenvolvi uma abordagem baseada em seis etapas:

Aprender
↓
Dialogar
↓
Simular
↓
Aplicar
↓
Revisar
↓
Documentar

Cada etapa possui um papel importante na construção do conhecimento.

📖 1. Aprender: compreender antes de aplicar

A primeira etapa consiste em compreender os fundamentos.

Durante meus estudos de Java, busquei entender não apenas como utilizar determinado recurso, mas principalmente:

• Por que esse conceito existe?
• Qual problema ele resolve?
• Quando essa abordagem faz sentido?

Alguns conceitos estudados:

• Classes e objetos;
• Encapsulamento;
• Herança;
• Polimorfismo;
• Interfaces;
• Organização de projetos;
• Boas práticas de desenvolvimento.

O objetivo sempre foi construir uma base sólida antes de avançar para conceitos mais complexos.

💬 2. Dialogar: utilizando IA como parceira de aprendizado

A Inteligência Artificial passou a ter um papel importante nessa jornada.

Porém, o objetivo nunca foi utilizar a IA como substituta do aprendizado ou simplesmente como uma ferramenta para gerar código.

O principal valor esteve no diálogo.

A IA passou a funcionar como uma parceira de reflexão técnica, ajudando a questionar decisões, explorar possibilidades e compreender melhor os conceitos envolvidos.

Algumas perguntas utilizadas durante esse processo:

• Essa solução faz sentido?
• Existe uma forma mais organizada de estruturar esse código?
• Essa classe possui responsabilidades demais?
• Como um desenvolvedor experiente avaliaria essa abordagem?
• Quais problemas essa decisão pode trazer no futuro?

Um ponto importante dessa experiência foi perceber que a IA não substitui o processo de pensar, pesquisar e tomar decisões.

Pelo contrário: ela amplia a capacidade de questionamento e acelera o aprendizado quando utilizada de forma consciente.

👥 3. Simular: observando o problema por diferentes perspectivas

Uma das experiências mais interessantes dessa jornada foi utilizar a IA para simular diferentes perspectivas inspiradas nos papéis existentes em uma equipe real de desenvolvimento.

A ideia não foi criar uma equipe real, mas utilizar diferentes pontos de vista para analisar um mesmo problema.

👨‍💻 Desenvolvedor

Perspectiva focada na implementação.

Principais questões:

• - Como resolver esse problema?
• - Qual estrutura utilizar?
• - Como aplicar os conceitos aprendidos?

🏗️ Arquiteto de Software

Perspectiva focada na organização da solução.

Questões analisadas:

• - Essa estrutura permite evolução?
• - As responsabilidades estão bem distribuídas?
• - Existe acoplamento desnecessário?
• - Essa solução pode crescer?

🧪 Analista de Qualidade (QA)

Perspectiva focada em cenários e validações.

Perguntas:

• - O que acontece em uma entrada inválida?
• - Quais situações extremas precisam ser consideradas?
• - O sistema está preparado para falhas?

📋 Product Owner

Perspectiva focada no problema que precisa ser resolvido.

Questões:

• - Qual necessidade estamos atendendo?
• - Essa implementação resolve o problema correto?
• - Estamos construindo algo que realmente agrega valor?

👨‍🏫 Professor / Mentor Técnico

Perspectiva focada na construção do conhecimento.

Esse papel foi importante para compreender conceitos de forma mais profunda.

A abordagem não era apenas receber uma resposta, mas entender:

• - Por que determinada solução funciona?
• - Quais conceitos estão envolvidos?
• - Quais alternativas existem?
• - Como esse conhecimento pode ser aplicado em outros contextos?

🔍 Code Reviewer

Perspectiva focada na qualidade da implementação.

Durante essa etapa, as perguntas passaram a ser:

• - O código está claro?
• - Os nomes representam bem suas responsabilidades?
• - Existe possibilidade de refatoração?
• - Outro desenvolvedor conseguiria compreender essa solução?

Essa etapa trouxe uma mudança importante de mentalidade:

Um código funcionando é apenas o começo.

🛠️ 4. Aplicar: transformando conhecimento em projetos

Após compreender conceitos e discutir possibilidades, o próximo passo foi aplicar o conhecimento através de projetos práticos.

Durante essa jornada, alguns projetos representaram etapas importantes da evolução:

🐶 PetMachine

Primeiro contato mais estruturado com Programação Orientada a Objetos.

Conceitos praticados:

• - Classes;
• - Objetos;
• - Encapsulamento;
• - Responsabilidade das classes.

O principal aprendizado foi entender como representar elementos do mundo real através do código.

---

🏦 Sistema Bancário

Um novo desafio: representar regras de negócio.

Aprendizados:

• - Validações;
• - Controle de estados;
• - Regras de funcionamento;
• - Organização da lógica.

---

🚗 Simulação de Carro

Um exercício focado em comportamento dos objetos.

Aprendizados:

• - Estados possíveis;
• - Restrições;
• - Responsabilidade dos métodos;
• - Modelagem de comportamento.

---

🎬 Sistema de Ingressos

Uma evolução importante utilizando conceitos mais avançados de orientação a objetos.

Conceitos aplicados:

• - Classe abstrata;
• - Herança;
• - Polimorfismo;
• - Interfaces;
• - Sobrescrita de métodos.

Esse projeto ajudou a compreender que orientação a objetos não é apenas reutilizar código, mas criar modelos que representem corretamente um domínio.

🔎 5. Revisar: melhorar continuamente

Uma das maiores mudanças durante essa jornada foi perceber que um código funcionando não significa necessariamente um código bem estruturado.

Com a evolução dos estudos, comecei a analisar:

• - Organização das classes;
• - Separação de responsabilidades;
• - Clareza do código;
• - Possibilidade de evolução futura.

A pergunta deixou de ser:

"O código funciona?"

E passou a ser:

"Essa solução está preparada para evoluir?"

Essa mudança representa uma transição importante entre apenas escrever código e começar a pensar como alguém que desenvolve software.

📝 6. Documentar: transformando aprendizado em portfólio

Outro aprendizado importante foi perceber o valor da documentação.

Registrar a evolução permite:

• - acompanhar o próprio crescimento;
• - compartilhar conhecimento;
• - receber feedback;
• - construir uma trajetória profissional.

Por isso, comecei a utilizar:

• - Git;
• - GitHub;
• - README estruturados;
• - histórico de evolução dos projetos.

O objetivo não é apenas armazenar código, mas registrar uma jornada de aprendizado.

🎮 Sudoku: um projeto em evolução

Atualmente estou desenvolvendo o desafio do **Jogo Sudoku em Java**.

Esse projeto representa uma nova etapa da jornada porque reúne diversos conhecimentos construídos anteriormente.

Mais do que implementar um jogo, estou utilizando o desafio como um laboratório para praticar:

• - organização de código;
• - resolução de problemas;
• - modelagem;
• - evolução incremental;
• - boas práticas de desenvolvimento.

O projeto ainda está em andamento e sua evolução pode ser acompanhada pelo GitHub:

📌 Repositório:

https://github.com/foliveiradark/dio-java-fundamentos/tree/main/poo/sudoku

A ideia é que o próprio histórico do projeto represente a evolução: desde as primeiras implementações até futuras melhorias de organização, arquitetura e qualidade do código.

💡 O impacto da minha experiência anterior nessa jornada

Minha trajetória profissional influenciou diretamente essa forma de aprender.

Minha experiência com gestão de projetos trouxe a importância de:

• - planejamento;
• - organização;
• - acompanhamento de evolução;
• - melhoria contínua.

Minha experiência com educação trouxe uma visão importante:

Aprender não é apenas receber informações.

É construir conhecimento através de:

• - prática;
• - reflexão;
• - questionamentos;
• - feedback.

Essa visão acabou sendo aplicada também ao aprendizado de programação.

🌱 Um aprendizado além do código

Durante essa jornada percebi que desenvolver software envolve muito mais do que escrever instruções para um computador.

Também envolve:

• - aprender continuamente;
• - comunicar ideias;
• - analisar problemas;
• - considerar diferentes perspectivas;
• - buscar melhoria constante.

Essas competências fazem parte da construção de um profissional de tecnologia.

🚀 Transformando desafios em oportunidades

Uma das maiores mudanças dessa jornada foi compreender que exercícios podem representar muito mais do que simples tarefas.

Um desafio pode ser:

❌ Apenas uma atividade para concluir.

Ou pode ser:

✅ Uma oportunidade para desenvolver pensamento técnico, experimentar decisões e construir algo demonstrável.

A diferença está na forma como encaramos o processo.

Conclusão

Minha principal conclusão até aqui é que aprender programação exige mais do que consumir conteúdos.

É necessário criar um processo onde conhecimento seja transformado em prática.

A Inteligência Artificial ampliou minha capacidade de aprendizado, não substituindo o desenvolvimento do raciocínio, mas funcionando como uma ferramenta de diálogo, reflexão e evolução.

Ao simular diferentes perspectivas de uma equipe de desenvolvimento, consegui analisar problemas por diferentes ângulos e desenvolver uma visão mais próxima da realidade profissional.

A tecnologia está mudando a forma como aprendemos e desenvolvemos software.

Mas o elemento principal continua sendo o mesmo:

A capacidade de aprender continuamente, fazer boas perguntas e evoluir através da prática.

🚀 A jornada continua.