Compensa trocar cursos de DEV por Guias criados por IA? · Anderson

Estou cansado e com nenhuma vontade de gastar dinheiro com cursos de programação, principalmente porque já estudei marketing digital e consigo identificar muitas mentiras por parte dos vendedores de curso online, não gosto de ser enganado e isso me incomoda muito.

Pensando nisso, decidi criar prompts pedindo para IA's criarem arquivos markdown explicando passo a passo o que eu quero aprender de forma guiada e sequencial e de forma extremamente prática.

Os resultados iniciais foram muito bons, porém, fico com receio da IA ensinar errado.

O que vocês acham? Qual a opnião de vocês?

Exemplo de prompt para estudar design patterns com Flutter.

You are a senior software engineer and educator with deep expertise in Object-Oriented Design, Design Patterns, Dart, and Flutter.

Your task is to create a **clear, didactic, and developer-friendly learning series** explaining Design Patterns, specifically tailored for developers using Dart and Flutter.

This material should transform Design Patterns from something abstract and academic into **practical tools for structuring real Flutter applications**.

You may use the explanations commonly taught in professional literature (such as the well-known catalog of patterns described at https://refactoring.guru/), but you MUST:

* Rewrite everything in your own words.
* Adapt all explanations to Dart language features and Flutter architecture.
* Avoid generic Java/C#-style examples unless translating them into Dart equivalents.

---

## Output Format (Important)

Generate **multiple Markdown files**, not a single document.

Each category of patterns must be placed into its own file:

01_what_are_design_patterns.md
02_creational_patterns_in_dart.md
03_structural_patterns_in_dart.md
04_behavioral_patterns_in_dart.md
05_patterns_in_flutter_architecture.md
06_when_not_to_use_patterns.md
07_real_world_flutter_examples.md

---

## Teaching Style Requirements

The explanations must be:

* Simple to understand, but NOT simplistic.
* Focused on intuition before formal definition.
* Written for a developer who already codes but wants architectural maturity.
* Grounded in real Flutter scenarios (state management, services, repositories, widgets, etc.).

Avoid academic tone. Prefer clarity and reasoning.

---

## Structure Required Inside Each File

Each Markdown file must follow this structure:

# <Topic Title>

## The Problem This Solves

Explain the real engineering pain that led to this pattern existing.

## The Core Idea

Describe the pattern in plain language first, without jargon.

## How It Works

Explain the mechanics and roles involved.

## Dart Implementation

Provide an idiomatic Dart example using:

* Classes
* Constructors
* Immutability where appropriate
* Null safety
* Async features when relevant

All code must compile conceptually in a Flutter project.

## Flutter Usage Example

Show where this pattern appears in Flutter apps, such as:

* Dependency Injection
* Repositories
* Widget composition
* State management
* Navigation
* Services
* Configuration objects

## Why It Fits Well (or Poorly) in Dart

Discuss how Dart language features influence the implementation:

* Named constructors
* Factory constructors
* Mixins
* Extensions
* Futures/Streams
* Isolates (if relevant)

## Common Misuses

Explain how developers overengineer or misuse this pattern in Flutter.

## When NOT to Use It

Clarify trade-offs and how patterns can harm readability if forced.

---

## Code Requirements (Strict)

Every code snippet must include **useful comments** explaining:

* The responsibility of each class.
* Why the pattern is structured this way.
* What problem it prevents in a growing codebase.

Do NOT include trivial comments like:
// create object

Instead include meaningful insight like:
// This factory centralizes creation logic so UI code never depends on concrete implementations.

---

## Additional Constraints

Do NOT:

* Copy examples from other languages.
* Use UI-heavy widget code unless necessary.
* Present patterns as “rules”.
* Suggest that every project needs them.

Do:

* Show patterns as tools for managing complexity.
* Emphasize maintainability and decoupling.
* Connect patterns to Clean Architecture concepts used in Flutter.

---

## End Goal

After reading all files, the developer should be able to:

* Recognize when a Design Pattern is appropriate.
* Implement patterns idiomatically in Dart.
* Avoid overengineering Flutter apps.
* Understand how patterns support scalable architecture rather than just “fancy code”.

Meus 2 cents,

Eu acredito que IA como tutor pode ajudar muito, afinal voce pode perguntar o quanto quiser que ela nao cansa, pedir para mudar a explicacao, etc.

Alguns detalhes:

coloque no prompt base alguns fundamentos, tais como pedir que os exemplos gerados sigam SOLID.
Dentro do razoavel, tambem coloque sobre Clean Code (DRY, KISS, YAGNI)
Lembrar de pedir para escrever testes unitarios quando possivel

Aprender eh praticar: peca para o modelo gerar propostas de sistemas simples onde voce possa implementar funcionalidades e que sejam facilmente verificaveis e auditaveis com boas praticas de desenvolvimento (pelo proprio LLM)

A vantagem do curso eh voce treinar com a orientacao de alguem que dedicou um certo tempo para criar um caminho mais adequado para um humano, coisa que a IA nao vai fazer com tanta atencao - alias, as vezes o caminho que a IA monta pode ser bem ruim.

Resumindo: humano eh importante para curadoria do conteudo, a IA nao tem muito bom senso para selecionar o que importa nem a ordem de apresentacao.

Mas uma pessoa com certa flexibilidade consegue driblar isso e aprender por conta.

Mas tambem eh verdade que nem todo mundo consegue - mas isso nao eh demerito nenhum, somos seres gregarios e a participacao em grupo neste sentido eh absolutamente normal.

Saude e Sucesso !