Video summary
estas tomando MAL los cursos...
Main summary
Key takeaways
Main ideas / lessons
- Most people don’t get value from online courses: they either don’t retain information, don’t apply it, or don’t finish (the speaker claims ~90% don’t finish). Even after finishing, learners may still feel “empty” because they learned content but can’t translate it into real actions.
- Getting 100% out of a course is about aligning the course with your goals and then using a structured approach:
- plan before the course (a “filter” to decide if you truly need it),
- participate actively during the course,
- implement and build after the course to turn viewing into real mastery.
- Courses work best as part of a bigger path (“a kingdom,” not “starting from many villages”).
- Two key questions to choose a course correctly:
- (Q1) What is my main objective? (long-term destination)
- (Q2) What do I need to achieve that objective? (the tool/learning steps—where a course may or may not fit)
- Active participation beats passive consumption: “memorizing” (storing) vs “remembering” (retrieval/application). Better memorization comes from engagement that strengthens associations.
- Real learning happens after finishing: skill mastery is demonstrated when you can apply knowledge in projects/practice.
- True mastery includes teachability: you don’t really know something until you can explain it clearly (communication vs teaching are treated as different).
Methodology / instructions (detailed)
1) Before the course (the “filter”)
A. Think of learning as a career, not a random activity
- A person leaves a career mainly due to:
- loss of interest (“got bored”)
- mismatch between expectations and reality (“nothing was different from what I thought”)
- Courses fail when learners don’t have a real destination and instead “test the waters” without a goal.
B. Use 2 decisive questions
Question 1: What is my main objective?
- Not “I want to know JavaScript/Python.”
- Instead: long-term outcomes like:
- becoming a programmer,
- getting hired,
- freelancing (selling websites),
- building a business / “software factory.”
- Trap to avoid:
- “This topic interests me, so I’ll take a short course.”
- This is not a goal; it’s experimentation.
Question 1 nuance (if you want to discover what you like)
- If you truly want to explore (web, mobile, AI, data analysis, UX/UI, etc.):
- you’re investing time, not necessarily wasting it,
- but before relying on courses, investigate what the role actually does (watch “what activities a X developer does,” not just “what you need to learn”).
Question 2: What do I need to achieve that goal?
- Identify whether the course is actually one of the steps toward your objective.
- If you discover there are no courses relevant to the needed steps, you may have wasted time.
- Suggested optional framework: SMART analysis
- Specific, Measurable, Achievable, Relevant, Time-bound
- Speaker’s personal tweak:
- replace “achievable” → “challenging”
- replace “measurable” → “trackable”
- If the course fits your needed path, it’s worth taking.
C. Example of why “tool ≠ job” (AI example)
- You may think: “To do AI, I need Python.”
- Speaker’s correction:
- Python helps implement programming-level tasks,
- but AI developer work also requires statistics, math, data modeling, building models, etc.
- So Python is not enough to judge whether you’ll like the real work—having the correct goal/role context matters.
D. Prep course before the main course: divide planning into phases
The speaker describes three preparation phases before starting a course (especially long ones).
1) Detailed research - Check the syllabus (coverage and order): - identify your interests, - spot where you’ll need extra support, - confirm completeness. - Research the instructor - consider teaching style and background/experience - preference: someone who can communicate clearly, not just someone with credentials. - Read reviews carefully - prefer reviews from people who actually watched/completed it - speaker warns against: - platforms where negativity goes viral, - relying on people who haven’t taken the course (opinion without direct experience). - suggests checking course/video comment sections for evidence (e.g., learners who got jobs/scholarships).
2) Prepare the environment - set up materials and workspace: - download required software (e.g., Visual Studio Code for dev courses), - organize folders, - ensure you can focus without disorganization. - goal: make the course process smooth and dedicated.
3) Review basic knowledge - if the course lacks prerequisites refreshers, do a mini-review first. - practical approach: - watch the first few minutes, - look up anything you don’t understand, - prevent confusion from accumulating.
E. Plan your time and study conditions
- choose a quiet, calm, distraction-free place
- define fixed study schedules (examples given):
- 3–4 pm daily,
- 2:30–4:30 pm,
- 1 hour morning + 1 hour afternoon,
- 1 hour afternoon + 1 hour night, etc.
- if professionally oriented, dedicate consistent time
- avoid “sometimes I’ll start” behavior:
- commit to finishing,
- don’t start unless you’re willing to invest the effort required.
F. Use study techniques
- Pomodoro Technique:
- 25 minutes focus + 5 minutes rest, repeated.
- Mini-goals
- if studying over months, define what you must learn each session
- if a task takes less time, use remaining time later—but still meet the goal
2) During the course (active participation)
Core principle
- Don’t be passively “watching.” Actively participate to make content sink in.
A. Understand memorizing vs remembering
- Memorizing: storing information.
- Remembering: retrieving it when needed.
- The more you engage in processes that strengthen recall pathways, the easier it becomes to use the knowledge.
B. Active participation methods
- Ask questions
- write questions ahead of time if materials are provided
- don’t fear mistakes; online course communities enable learning
- Join discussion/communities
- join relevant groups (example mentioned: Cflow; also general advice to join communities like groups/Reddit/Facebook)
- Collaborate with other students
- create study groups (WhatsApp/Telegram)
- use Discord
- pause videos and help each other with questions
- Copy-and-do, not just watch
- if the instructor writes code: write your own
- if building a funnel/design: build it yourself
- Create variations
- don’t always copy the exact output
- if you can only reproduce the “nice” version by copying:
- it suggests you didn’t understand deeply enough
- encourage alternatives/styles/functionality—there are multiple ways to achieve the same goal
3) After the course (implementation and mastery)
Core principle
- Finishing a course is not mastery—it’s the beginning.
- True learning is demonstrated by applying what you learned in real practice.
A. Step 1: Real-world implementation
- Start building projects that use the learned concepts.
B. Step 2: Start small
- Don’t jump into a huge multi-month project immediately.
- Use small “mini-projects” to apply one piece at a time and avoid frustration.
C. Step 3: Set new objectives after finishing
- Example: “I watched everything; now my next objective is…”
- Build a new learning/project direction based on what you now want to accomplish.
D. Step 4: Apply knowledge by thinking in “tool ↔ objective” connections
- The speaker suggests reversing the usual order:
- instead of “I learned a tool so I use it,” ask:
- “Where is this tool best? What objectives does it serve?”
- Examples implied:
- HTML concepts (e.g., scroll-based animations) → think how to apply them in your own projects
- CSS Grid → when is Grid the best layout choice?
- Python → when/which libraries make sense for specific tasks
E. Step 5: Build a portfolio
- Create a portfolio to:
- demonstrate skills to companies,
- continuously improve through more projects.
F. Step 6: Continuing education (build your own learning path)
- Don’t assume one course makes you “dominate the world.”
- If the course doesn’t explain how to continue:
- build a learning curve/map:
- what to learn next,
- how to proceed,
- what other skills/tools you need.
- build a learning curve/map:
- The speaker emphasizes: the most important skill is learning how to learn.
4) Closing framework: mastery proof = teachability
- A personal “filter” for knowing something is real mastery:
- If you can’t explain it (teach it) to someone else, you likely don’t understand it.
- Communication vs teaching are treated as different:
- you can communicate well without being able to teach effectively.
- Suggested ways to test mastery:
- talk to classmates,
- write blogs,
- create your own videos.
Speakers / sources featured
- Speaker: Dalto (primary speaker; also references himself as a creator/instructor of courses)
- Mentions / implied sources (not additional speakers):
- ChatGPT (used as a tool for evaluating syllabus completeness)
- Pomodoro Technique (method name; attributed generally, not to a specific person in the subtitles)
- Reddit / Twitter / Instagram (platforms referenced for review credibility and community presence)
- YouTube (source of course content and research videos)
- Facebook / WhatsApp / Telegram / Discord (community platforms mentioned for active learning and collaboration)
- Cflow (community mentioned for programming collaboration/participation)