leetcode is useless

Main ideas / concepts / lessons

• “LeetCode is useless” is questioned and reframed

  • The speaker argues that although LeetCode is often dismissed as not directly matching job tasks, solving ~1,000+ problems (they cite 1,364) builds auxiliary skills that transfer to real work.

• Transferable skills from hard problem-solving

  • LeetCode practice is compared to learning math/physics in school:
    • People initially see topics as pointless (“why learn this?”),
    • but later it becomes clear that grappling with fundamentals strengthens thinking and capability.
  • The speaker claims that solving difficult algorithmic problems builds:
    • foundational problem-solving ability,
    • better reasoning and “levels of thinking,”
    • debugging and algorithmic thinking in day-to-day work.

• Work ethic / grind as a hidden benefit

  • The speaker observes that people who do lots of LeetCode (1,000–3,000 problems) tend to:
    • work very hard,
    • handle challenges without much complaining,
    • act like “good employees.”

• A critique of how LeetCode is presented

  • They argue that presentation/marketing and framing can “turn people off” immediately (e.g., how the video starts causes people to disengage).
  • They wonder how to “make LeetCode good again.”

• Proposed improvement: “Build your own X” but LeetCode-focused

  • Idea: instead of isolated problem sets, guide users to build real projects that internally involve common LeetCode concepts.
  • They propose removing parts that feel scary or irrelevant:
    • keep the core algorithms/data structures,
    • reduce heavy object-oriented/design complexity,
    • present tasks as smaller implementation steps (e.g., “implement this method”).
  • Goal: users shouldn’t feel they’re doing problems “to no avail,” but instead producing something tangible (like a working database).

• Trying a related approach: CodeCrafters

  • The speaker discusses CodeCrafters (a “build your own X” style platform) and evaluates:
    • whether it has enough guided structure,
    • whether it could be adapted into a LeetCode-centered version.
  • They remark on the platform’s monetization/margins and speculate about costs, implying they may be mostly educational (unit tests / repo + user execution).

• Practical positioning for learners

  • The speaker emphasizes a business/learning constraint:
    • Getting people to pay (especially with limited money) is extremely difficult.
  • They propose that their own version could be marketed as:
    • LeetCode for getting a job, i.e., tied to a clearer financial outcome.

• Demonstration: first steps in CodeCrafters

  • They show downloading a GitHub repo and passing “stages.”
  • Example task described:
    • implement support for printing error messages for invalid commands.
    • The required output format is: Command not found.
  • They express enthusiasm for the approach because it feels like LeetCode “inside projects,” and that doing this would strengthen skills (especially arrays/strings) more effectively than just doing problems.

• Lead-in to another offer (unrelated product promotion)

  • The speaker promotes a free roadmap for getting a tech job:
    • mentions it compresses 200+ hours into chunks,
    • includes stages for beginners, new grads, and experienced candidates,
    • claims it covers going from no interviews / failing interviews to solving 1,000 LeetCode problems and passing interviews.

Methodology / “how it’s done” (as described)

A) How the speaker envisions “LeetCode, but better”

• Build a platform using a “Build your own X” model:
  • Choose a project domain (e.g., build a database).
  • Extract the relevant learning targets:
    • data structures (e.g., trees),
    • core algorithms used in the project’s features.
  • Provide exercises that focus on implementation steps rather than large architectural/design efforts:
    • “Implement this method,” “Implement this method,” etc.
  • Let learners interact with the system so they directly “use the tree / data structure,” rather than just reading about it.
• Add enough scaffolding so it doesn’t feel:
  • too confusing or scary,
  • but still not overly “handholdy.”

B) How CodeCrafters-style tasks work (per the speaker’s walkthrough)

• User selects a project challenge track (“stages”).
• The platform provides a GitHub repo for the user to download.
• User implements required functionality in the provided codebase.
• User submits changes to pass each stage.
• The platform validates output via expected formatting and tests.
• Example stage mentioned:
  • Implement invalid-command handling so the program prints the exact error:
    • Command not found.

Speakers / sources featured (at end)

• Speakers

  • The video’s primary speaker (unnamed).

• Sources / referenced entities

  • LeetCode (as a concept/platform)
  • LSAT (mentioned as a test used for law school admissions)
  • CodeCrafters (platform being evaluated)
  • GitHub repositories (used as the project template in CodeCrafters)
  • “School.com/raund” and a “Ray’s roadmap” (promoted resource; unnamed brand/person “Ray” is referenced)