Apresentação do método e plataforma **SolveIt** (Jeremy Howard /…

INEMA

Você pode acessar a plataforma SolveIt através deste link:

https://solveit.fast.ai/ (solveit.fast.ai)

Esse site apresenta o curso “How to Solve It With Code”, que utiliza o ambiente SolveIt para ensinar a metodologia dialogue engineering e desenvolvimento iterativo. É por meio dessa plataforma, contínua e interativa, que Jeremy Howard e Johno Whitaker conduzem o aprendizado baseado em pequenos passos, feedback ativo e uso colaborativo de IA. (answer.ai)

Jeremy Howard e Johno Whitaker falaram de uma plataforma chamada SolveIt, criada pela Answer.AI.

Pontos principais sobre a plataforma:⌗

SolveIt é um ambiente digital desenvolvido para aplicar o chamado método SolveIt, baseado em resolver problemas em pequenos passos iterativos (inspirado em Pólya, Toyota, Lean Startup e OODA Loop).
A ferramenta foi construída para estimular a mentalidade de prática deliberada, reflexão e melhoria contínua — não apenas gerar código rápido como no “vibe coding”.
Funciona como um ambiente integrado de notebooks interativos, mas com recursos diferenciados:
Mistura código, notas, prompts de IA e resultados no mesmo fluxo.
Permite que a IA veja o que você já escreveu e sugira melhorias de forma contextual.
Incentiva documentar, validar cada etapa e refletir antes de avançar.
Tem recursos de literate programming: código, testes e documentação no mesmo lugar.
Dá suporte a criação de apps reais (usando FastHTML e outras libs) dentro do próprio ambiente.
Jeremy mostrou exemplos práticos dentro da plataforma:
Resolver puzzles do Advent of Code.
Criar quiz de identificação de espécies com API do iNaturalist.
Construir web apps interativos.
Usar APIs complexas (como Cloudflare) com ajuda da IA de forma guiada.

Ou seja, SolveIt é tanto uma metodologia quanto uma plataforma de apoio que facilita trabalhar nesse estilo iterativo, documentado e reflexivo.

youtube.com/watch ↗

e-mail vira e mail). Aceitável para objetivo; se necessário, ajustar regra para preservar hifens internos.

iteração 6 — literate style e docstring clara

def top_words(text, n=5, stopwords=None): """ Conta as n palavras mais frequentes em português. Passos: 1) lower + remoção de acentos (NFD) 2) separa hifens internos e remove pontuação 3) filtra stopwords configuráveis Retorna: lista de tuplas (palavra, contagem) ordenada por frequência. """ stop = set(stopwords or PT_BR_SW) t = normalize(text) tokens = [tok for tok in t.split() if tok not in stop] from collections import Counter return Counter(tokens).most_common(n)

Exemplo final: Entrada: "Informação prática é poder. A informação correta, no momento certo, muda tudo. Informação!" Saída: [('informacao', 3), ('pratica', 1), ('poder', 1), ('correta', 1), ('momento', 1)]

iteração 7 — onde a IA ajuda sem cair no vibe coding

Brainstorm de casos de borda: pedir à IA uma lista de frases com acentos, gírias, números e pontuação estranha para testar.
Geração de stopwords base: pedir um conjunto inicial e depois revisar manualmente.
Verificação de regex: pedir à IA explicações/alternativas para regras de hifenização sem alterar o escopo de uma vez.
Escrita de testes unitários: solicitar à IA rascunhos de testes pytest para nossos exemplos; você executa e ajusta.
Refatoração guiada: pedir sugestões de nomes de função, docstrings e micro-otimizações, mantendo o comportamento verificado pelos testes.

ciclo solveit aplicado (miniloop OODA + lean) Observar: saída errada para acentos/pontuação. Orientar: decidir normalizar por NFD e regex simples. Decidir: aplicar transformações mínimas e testar. Agir: ajustar código, reexecutar testes, documentar. Repetir: adicionar stopwords, revisar hifens, escrever docstring, criar testes.

lista de tópicos com exemplos e respostas

Por que pequenos passos? Exemplo: primeiro só lower(); depois acentos; depois pontuação; cada passo testado evita quebrar o que já funciona. Resposta: reduz risco, aumenta aprendizado e dá visibilidade do que realmente melhora.
Como validar cada etapa? Exemplo: testes de fumaça antes e depois de cada mudança (e.g., "Informação!" → "informacao"). Resposta: use entradas mínimas, compare saída esperada e só então avance.
Onde a IA entra? Exemplo: pedir casos de borda e rascunhos de testes. Resposta: IA como copilota de ideias e revisão; você mantém o controle das decisões.
O que é deliberate practice aqui? Exemplo: fazer e refazer pequenas funções, medindo entendimento por testes. Resposta: foco em melhorar habilidade, não só “passar de fase”.
Por que literate programming? Exemplo: docstrings e comentários que contam a história do raciocínio. Resposta: facilita manutenção, onboarding e reuso do conhecimento.
Como aplicar Lean/OODA? Exemplo: construir→medir→aprender em ciclos curtos; observar→orientar→decidir→agir em cada microajuste. Resposta: acelera feedback útil e evita overengineering.
Como evitar “vibe coding”? Exemplo: não pedir à IA “faça tudo”: em vez disso, peça “liste casos de teste para pontuação”. Resposta: delimite tarefas, valide, itere.
Como medir que o sistema ficou sustentável? Exemplo: adicionar um novo conjunto de stopwords não quebra o restante. Resposta: testes estáveis e funções coesas indicam sustentabilidade.

Aqui vai um exemplo prático, no estilo SolveIt, resolvendo um problema simples de dados em pequenos passos iterativos, com validação, reflexão e uso da IA como apoio estratégico.

tarefa Contar as n palavras mais frequentes de um texto em português, ignorando maiúsculas/minúsculas, acentos e stopwords, com testes rápidos de verificação.

critérios de aceitação

A função top_words(texto, n=5) retorna lista de tuplas [(palavra, contagem), ...].
Normaliza acentos e caixa.
Remove pontuação simples e stopwords configuráveis.
Passa por testes de fumaça e casos de borda básicos.

plano em passos curtos Passo 1: tokenizar e contar Passo 2: normalizar caixa e acentos Passo 3: remover pontuação e hifens soltos Passo 4: filtrar stopwords Passo 5: validar com testes e refletir sobre erros Passo 6: refatorar e documentar (literate style) Passo 7: onde a IA apoia sem “vibe coding”

iteração 1 — tokenizar e contar Objetivo: ter algo funcionando, mesmo que imperfeito. Código mínimo:

```from collections import Counter

def top_words(text, n=5): tokens = text.split() # ainda ingênuo c = Counter(tokens) return c.most_common(n)```

Teste rápido: Entrada: "Casa casa CASO caso" Saída esperada: conta distingue caixa (ainda errado para nosso objetivo). Reflexão: precisamos normalizar caixa.

iteração 2 — normalizar caixa

def top_words(text, n=5): tokens = text.lower().split() from collections import Counter return Counter(tokens).most_common(n)

Teste: "Casa casa CASO caso" → [('casa', 2), ('caso', 2)] Reflexão: melhorou, mas acentos e pontuação ainda quebram: "informação, Informacao!" devem agrupar.

iteração 3 — remover acentos

```import unicodedata from collections import Counter

def strip_accents(s): return ''.join( ch for ch in unicodedata.normalize('NFD', s) if unicodedata.category(ch) != 'Mn' )

def top_words(text, n=5): text = strip_accents(text.lower()) tokens = text.split() return Counter(tokens).most_common(n)```

Teste: "informação, Informacao!" → tokens ainda incluem pontuação: 'informacao,' e 'informacao!'.

iteração 4 — limpar pontuação e hifens soltos Decisão: trocar qualquer caractere não alfanumérico por espaço, mas preservar dígitos (ex: ipod2). Tratar hifens: se for interno e cercado por letras, trocar por espaço para separar compostos simples.

```import re import unicodedata from collections import Counter

def strip_accents(s): return ''.join(ch for ch in unicodedata.normalize('NFD', s) if unicodedata.category(ch) != 'Mn')

def normalize(text): t = strip_accents(text.lower()) # separa hifens em palavras compostas simples t = re.sub(r'(?<=\w)-(?=\w)', ' ', t) # remove tudo que não for letra/dígito/underscore t = re.sub(r'[^a-z0-9_]+', ' ', t) return t.strip()

def top_words(text, n=5, stopwords=None): stopwords = set(stopwords or []) t = normalize(text) tokens = [tok for tok in t.split() if tok not in stopwords] return Counter(tokens).most_common(n)```

Teste: "informação, Informacao!" → [('informacao', 2)]. Bom.

iteração 5 — stopwords e casos de borda Adicionar um conjunto leve de stopwords PT-BR e testes:

```PT_BR_SW = { 'a','as','o','os','um','uma','de','do','da','dos','das', 'e','ou','em','no','na','nos','nas','por','para','com', 'que','se','ao','aos','à','às','àquela','aquele','aquilo', 'este','esta','isto','isso','aquele','era','ser','sao','é' }

def top_words(text, n=5, stopwords=None): stop = set(stopwords or PT_BR_SW) t = normalize(text) tokens = [tok for tok in t.split() if tok not in stop] from collections import Counter return Counter(tokens).most_common(n)```

Testes rápidos (fumaça):

Texto vazio → []
Somente stopwords: "o a e de" → []
Hífens: "linha-de-base linha de base" → contar linha, de, base; após stopwords, espera ['linha','base'] com contagens coerentes.
Acentos: "ação acao AÇÃO" → 'acao' com contagem 3.

Reflexão: nossa regex simplifica demais compostos (ex:

Preparei um guia de bolso do método SolveIt, direto ao ponto, em formato “faça isso / evite aquilo” para consulta rápida:

Guia de Bolso SolveIt⌗

1. Avance em passos curtos⌗

Faça: implemente mudanças mínimas e valide logo.
Evite: pedir para a IA gerar o projeto inteiro de uma vez.

2. Teste antes de seguir⌗

Faça: rode um teste rápido (entrada simples → saída esperada) a cada ajuste.
Evite: acumular muitas mudanças sem validar.

3. Use erros como aprendizado⌗

Faça: reflita sobre por que deu errado e ajuste o próximo passo.
Evite: apenas pedir “corrija o erro” para a IA sem entender.

4. Documente o raciocínio⌗

Faça: escreva comentários e docstrings explicando o porquê, não só o como.
Evite: deixar o código como “caixa preta” gerada pela IA.

5. Use a IA como copiloto estratégico⌗

Faça: peça ideias de testes, casos de borda, alternativas de regex ou refatorações.
Evite: terceirizar o raciocínio principal para a IA.

6. Foque em aprendizado acumulado⌗

Faça: transforme cada iteração em fundamento sólido (que pode ser reutilizado).
Evite: soluções descartáveis que você não entende.

7. Trabalhe no ciclo OODA / Lean⌗

Faça: Observar → Orientar → Decidir → Agir → repetir rápido.
Evite: planejar demais sem experimentar ou improvisar sem refletir.

8. Mantenha a simplicidade sustentável⌗

Faça: priorize soluções simples, testáveis e fáceis de explicar.
Evite: complicar cedo demais ou depender de mágica da IA.

Aqui está um resumo claro e estruturado com Jeremy Howard e Johno Whitaker sobre o ambiente SolveIt:

1. Contexto e Objetivo⌗

Jeremy Howard (FastAI / AnswerAI) apresenta o SolveIt, fruto de mais de 10 anos de experiência e 1 ano de dedicação intensa.
O propósito não é apenas um software, mas uma mentalidade de trabalho: resolver problemas em pequenos lotes (small batches), aplicando práticas de aprendizado deliberado e melhoria contínua.
A ideia vem de tradições como Lean Startup, Toyota Production System, UDA Loop e o livro clássico How to Solve It de George Pólya.

2. Crítica ao “Vibe Coding”⌗

Vibe coding (pedir para a IA gerar tudo de uma vez) dá um “dopamine hit”, mas não constrói competência.
Produz resultados de curto prazo, mas não gera bases sólidas, aprendizado real nem sistemas sustentáveis.
Não há casos de grandes startups ou sistemas complexos criados com vibe coding.

3. A Metodologia SolveIt⌗

Você é o agente (agentic human), não a IA.
O sistema é feito para tornar o humano mais competente a cada dia.
Estrutura baseada no loop iterativo:

Entender o problema (ler, reformular, verificar entendimento).
Gerar múltiplas estratégias (analogias, referências, IA pode sugerir adicionais).
Implementar passo a passo (1–2 linhas de código por vez).
Refletir e revisar (analisar resultados, identificar bugs, melhorar). * Esse ciclo se aplica de escala macro (um projeto inteiro) até micro (uma linha de código).

4. Práticas-Chave⌗

Aprendizado deliberado: sempre praticar o que é difícil, em pequenos blocos, mesmo que mais lento.
Fundamentos fortes: cada passo constrói uma base reutilizável, tanto para o humano quanto para o LLM.
Literate Programming: código, documentação e exemplos de uso ficam juntos e vivos.
Ergonomia do fluxo: atalhos, blocos interativos e ambiente dinâmico incentivam o aprendizado ativo em vez da dependência da IA.
Evitar dívida técnica: o progresso deve tornar cada tarefa futura mais fácil, não mais difícil.

5. Demonstrações no Vídeo⌗

Exemplo com iNaturalist:
Obter observações via API.
Criar questões de múltipla escolha para testar LLMs na identificação de espécies.
Iterar passo a passo: buscar dados, gerar opções, validar resultados, consolidar em funções.
Construção de apps web com FastHTML:
Criar um quiz interativo totalmente dentro do SolveIt.
Mostrar que é possível desenvolver aplicações completas sem sair do ambiente.
Uso de APIs complexas (Cloudflare):
Demonstrar como escrever funções auxiliares, transformar em ferramentas, e deixar o LLM usá-las agenticamente.

6. Comunidade e Público-Alvo⌗

Resolve bem para iniciantes (até 3 anos de experiência) e para veteranos (20+ anos), porque ambos estão abertos a aprender.
Programadores intermediários (3–20 anos) tendem a resistir por acharem que já dominam práticas tradicionais.
A comunidade SolveIt tem papel central: feedback, compartilhamento de falhas e sucessos, prática colaborativa.

7. Filosofia Final⌗

O objetivo não é apenas codar mais rápido, mas criar um ciclo positivo de aprendizado e evolução contínua.
Ao invés de delegar tudo à IA, o SolveIt ensina a trabalhar junto com a IA, em pequenos lotes, ganhando profundidade, compreensão e capacidade real.
Muitos usuários relatam que a prática é transformadora, não por mágica imediata, mas pelo efeito acumulativo de semanas e meses de prática consciente.

O que é o SolveIt⌗

Ambiente e método criado por Jeremy Howard e Johno Whitaker.
Focado em mudar a forma de programar com IA: menos dependência de geração mágica e mais construção de competência.

Diferença em relação ao “vibe coding”⌗

Vibe coding: pede tudo de uma vez para a IA → resultado rápido, mas pouco aprendizado humano.
SolveIt: trabalho em pequenos passos iterativos → cada erro vira aprendizado, cada avanço consolida entendimento.

Princípios que sustentam o SolveIt⌗

Deliberate practice

Treino intencional e focado, com feedback contínuo.
O objetivo é evoluir a habilidade, não apenas resolver a tarefa.

Literate programming

Código escrito como narrativa, legível tanto para humanos quanto para máquinas.
Explicação e raciocínio são parte central do processo.

Metodologias de inovação

Lean Startup: construir, medir e aprender em ciclos curtos.
Ciclo OODA (Observar, Orientar, Decidir, Agir): tomada de decisão ágil baseada em feedback constante.

Como funciona na prática⌗

Resolver problemas passo a passo, validando cada resultado.
Refletir sobre erros e reformular a abordagem.
Usar a IA como apoio estratégico, não como substituto do raciocínio humano.
Documentar e explicar o raciocínio para acumular fundamentos sólidos.

Benefícios do método SolveIt⌗

Desenvolvimento real de competência técnica e pensamento crítico.
Criação de sistemas mais sustentáveis e compreensíveis.
Formação de uma base duradoura de aprendizado, ao invés de soluções descartáveis.
Estímulo ao protagonismo humano, com a IA como parceira estratégica.

Apresento o SolveIt, um ambiente e método criado por Jeremy Howard e Johno Whitaker que propõe uma forma diferente de programar e resolver problemas com IA: em vez do “vibe coding”, que gera tudo de uma vez mas não constrói aprendizado, o SolveIt incentiva o trabalho em pequenos passos iterativos, validando cada etapa, refletindo sobre erros e acumulando fundamentos sólidos. Essa abordagem combina conceitos de deliberate practice, literate programming e metodologias como Lean Startup e o ciclo OODA, permitindo que humanos sejam os agentes principais do processo, desenvolvendo competência real, sistemas sustentáveis e um ciclo contínuo de melhoria, ao mesmo tempo em que utilizam a IA como apoio estratégico.

Resolva AI com Acompanhamento Humano

SOLVEIT - Metodo novo 2025

chatgpt.com ↗

Apresentação do método e plataforma SolveIt (Jeremy Howard /…