How to Learn FASTER
Based on Joshua Duffney's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.
Convert learning goals into a scoped project with a concrete deliverable, rather than relying on reading or course completion alone.
Briefing
Learning difficult skills faster comes down to turning them into tightly scoped projects—then practicing them in the real context where the knowledge will actually be used. Joshua Duffney frames “elasticity” as a strength in systems design, but pivots to knowledge work: the ability to learn hard things quickly is a practical, necessary advantage. His method is built around an “ultra learning” project template credited to Scott Young’s book *Ultra Learning*, using it to stay accountable, reduce procrastination, and convert research into usable capability.
The process starts with a “meta learning research spike.” Instead of diving deep immediately, a learner picks a topic (for example, Go web development) and gathers enough exposure to shape a project that can be completed on a realistic timeline. That exposure comes from skimming books, reading blogs, and sampling course material—Duffney cites watching roughly half of an Udemy course (about 10 hours) plus additional blog research and conversations with working experts. He emphasizes keeping the resource list small—primary resources should be limited to a handful (he suggests no more than five, with three often being enough) so the learner doesn’t drown in consumption and delay the actual work.
Next comes refining the scope so the learning ends with something tangible. For his example, the goal is not “learn web development,” which could take years, but “build a JSON-based web service in Go that connects to a database.” He narrows the project by selecting common, practical components: JSON for request/response payloads, an API-style REST approach, and persistent storage in a database. The timeline matters because *Ultra Learning* recommends scoping projects to roughly three to six months maximum; Duffney chooses a much shorter window—two weeks—so the work stays intense but finishable.
The core learning mechanism is “directness” or “direct practice,” a concept Duffney links to deliberate practice and *Peak* (along with *Ultra Learning*). The key idea is that knowledge transfer fails when learning stays abstract—reading and watching without coding doesn’t prepare someone for the environment where the skill will be used. Direct practice means building immediately: in his case, creating an API endpoint that lets him store favorite books in a database. He also argues that this can run in parallel with research, so the project becomes an active constraint that forces the learner to apply what they’re consuming.
Finally, the method relies on scheduling and commitment. Duffney uses an “implementation intention”-style plan: decide how much time to commit (he uses one hour each morning, seven days a week), pick a consistent time window (around 5:30–6:30 a.m.), and set a sprint-like project length (two weeks, or 14 days). He also sets a concrete target end date—by the first of next year—so the learning has a finish line. He notes he doesn’t use the full framework for casual exploration, but he falls back on it when he wants to learn something well and is prone to procrastination.
Cornell Notes
The fastest way to learn a difficult skill is to convert it into a short, concrete project with a clear scope, then practice directly in the context where the skill will be used. Duffney’s workflow starts with a “meta learning research spike”: gather enough books, blogs, course material, and expert input to shape the project, while limiting primary resources to a small set (often three). He then narrows the scope to something finishable—his example is a two-week Go project building a JSON-based web service that connects to a database. The learning engine is “directness” (direct practice): coding the project while consuming material, so knowledge transfers instead of staying theoretical. A strict schedule—time, start time, and sprint length—keeps the plan accountable and reduces procrastination.
What is a “meta learning research spike,” and why does it come before deep study?
How does Duffney decide what to build—what makes a good learning project scope?
What does “directness” (direct practice) mean in practice?
Why limit primary resources, and what’s the risk of not doing so?
How does scheduling turn learning into something the learner can actually complete?
Review Questions
- What steps make up Duffney’s learning workflow, and where does the “meta learning research spike” fit relative to building?
- In his Go example, which specific features (JSON, API endpoints, database persistence) define the project’s scope and why?
- How does direct practice improve knowledge transfer compared with reading or watching alone?
Key Points
- 1
Convert learning goals into a scoped project with a concrete deliverable, rather than relying on reading or course completion alone.
- 2
Start with a “meta learning research spike” to gather enough information to design the project, then move quickly into building.
- 3
Keep primary learning resources limited (often three) to avoid getting trapped in endless consumption.
- 4
Use “directness” by coding in the same context where the skill will be applied, so knowledge transfers through practice.
- 5
Refine the scope to something finishable in weeks; Duffney’s example narrows web development to a two-week Go JSON API with database storage.
- 6
Schedule learning like a commitment: pick a daily time window, a consistent start time, and a sprint-length deadline to reduce procrastination.
- 7
Run research and building in parallel so the project actively forces application of what’s being studied.