Get AI summaries of any video or article — Sign up free
10 ways I learn in public thumbnail

10 ways I learn in public

5 min read

Based on Nicole van der Hoeven's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

Share work-in-progress, not just finished answers, because visible effort makes feedback more actionable.

Briefing

Learning in public works best when it turns uncertainty into usable feedback. Instead of waiting to be fully right, Nicole van der Hoeven argues for sharing “work in progress” so others can respond, correct, and build on what’s already been attempted. A guiding idea—often linked to Cunningham’s Law—is that posting a flawed question or draft can draw better answers than staying silent, because showing the work makes it easier for people to react concretely.

The approach starts with answering questions even when the answer isn’t polished. The emphasis is on authenticity: don’t perform expertise if confidence is low. A wrong answer can still trigger learning—either by prompting someone else to correct it or by helping others refine the reasoning. From there, the learning loop expands into public artifacts. Van der Hoeven highlights raising pull requests on GitHub even when a more elegant solution exists, framing mistakes as part of the collaborative process and giving both others and oneself permission to be imperfect.

Reading and note-taking become public-facing through curated highlights. Using Readwise with an Obsidian workflow, she imports highlights into an Obsidian vault and publishes them via Obsidian Publish. The result is a public library where even unfinished literature review notes can be valuable. Readers can see what chapters were highlighted, and comments made on a Kindle can be converted into headings automatically—turning casual reading signals into structured, searchable knowledge. The payoff isn’t just personal organization; it’s community interaction, including people looking up what she highlighted before they even start reading.

Sharing what’s learned matters as much as collecting it. She points to Josh Brown’s “TIL” (Today I Learned) GitHub repository as a model: short, daily snippets tied to specific needs—like practical Go build commands for a particular OS/architecture—rather than comprehensive tutorials. Her own version uses Mastodon and a hashtagged #til stream to document small discoveries, even when they’re recorded “live” alongside the learning process.

Publishing notes online increases the chance of targeted feedback. She publishes a large share of her notes (about 80%), not because every note is brilliant, but because visible drafts invite critique. In one example, showing a Kubernetes monitoring page enabled a friend to suggest concrete restructuring; asking from scratch would likely have produced a less useful response. She also keeps a public changelog using a Vault Changelog plugin, including a fork that adds features like excluding folders.

The list continues with interactive formats: live streams such as Grafana Office Hours, where engineers are interviewed and questioned by others; and slide-based presentations built from markdown using Obsidian’s Slides ecosystem (including Advanced Slides). She recommends recording the learning process in videos, writing newsletters or blog posts for a more polished consolidation (using Buttondown with an Obsidian integration), and even applying “canary deployment” thinking—rolling out new work to a small inner circle, then a friendly public audience, before going fully public.

Finally, the most ambitious step is writing a book in public. The project, titled Doing It in Public, is framed as another form of progress-sharing: outlining, drafting, and inviting feedback through Discord, GitHub issues, Mastodon posts, or the book’s published materials. The throughline across all ten methods is simple: share enough of the work to invite real, actionable responses—then iterate with the help of others.

Cornell Notes

Learning in public is most effective when it shares “work in progress” rather than waiting to be fully correct. Van der Hoeven emphasizes authenticity—answering questions and posting drafts even when uncertain—because visible effort makes feedback easier and often leads to better corrections. She describes a workflow that turns reading into public highlights (Readwise → Obsidian → Obsidian Publish), then extends it into public notes, changelogs, and short “Today I Learned” style posts. Interactive formats like live interviews and slide decks, plus iterative rollout strategies like canary deployments, help reduce the fear of going from private to fully public. The ultimate goal is to write a book in public, using the same feedback-driven mindset.

Why does posting imperfect questions or drafts tend to produce better answers than waiting to be sure?

The core idea is that feedback becomes easier when others can see the work. Instead of asking a polished, abstract question, sharing a flawed attempt gives people something concrete to react to—whether that means correcting the mistake, pointing to the right direction, or refining the reasoning. Van der Hoeven links this to Cunningham’s Law (noting it’s often misattributed), using it to justify answering questions even when not fully confident.

How can reading highlights become a public learning resource rather than private note-taking?

She uses Readwise to collect highlights from books, then imports them into Obsidian via the Readwise official community plugin. Those notes are published through Obsidian Publish, creating a public vault. Even if she doesn’t write formal notes while reading, the highlights themselves can spark value—people comment on what she highlighted, look up books based on chapter highlights, and she can also add lightweight structure (e.g., Kindle comments that become headings in Obsidian via a “.h1” marker).

What makes “Today I Learned” style posts useful compared with long explanations?

The usefulness comes from specificity and practicality. She cites Josh Brown’s TIL GitHub repository as an example where daily snippets are often one-liners or small code fragments tied to a real need. Instead of covering the full history of a topic, the entries focus on what was required that day—like Go build commands for a specific OS/architecture—so readers can reuse the exact solution when they face the same problem.

How does publishing notes online improve the quality of feedback?

Visible drafts invite targeted critique. She publishes around 80% of her notes online and says the value isn’t perfection—it’s accessibility. When someone can see the work already done (for example, a Kubernetes monitoring page), they can suggest concrete restructuring. She contrasts this with asking broadly from scratch, which would likely yield less specific guidance.

What does “canary deployment” mean in the context of learning in public?

It’s a phased rollout to manage risk. Instead of going from private to fully public, she describes an inner circle of friends for early review, then a friendly public audience (like patrons) for early access, and only then a full public release. The goal is to gather feedback and confidence gradually, similar to how software teams test stability with a small user percentage first.

What tools and platforms support her public learning workflow?

Her workflow centers on Obsidian and publishing: Readwise feeds highlights into Obsidian; Obsidian Publish publishes the vault; Obsidian plugins support features like Slides/Advanced Slides for presentations and Vault Changelog for public change tracking. For newsletters, she uses Buttondown, chosen partly for its Obsidian integration that creates drafts from notes. For social learning and short updates, she uses Mastodon with a #til hashtag.

Review Questions

  1. Which parts of the learning process become more “feedback-friendly” when they’re shared publicly, and why?
  2. How do Readwise highlights and Obsidian publishing work together to create a public knowledge base even without full notes?
  3. What phased-sharing strategy (canary deployment) does she recommend to reduce the fear of going fully public, and what are the stages?

Key Points

  1. 1

    Share work-in-progress, not just finished answers, because visible effort makes feedback more actionable.

  2. 2

    Answer questions even when uncertain, as long as the uncertainty is communicated and authenticity is maintained.

  3. 3

    Turn reading into public learning by importing highlights into Obsidian and publishing them, so others can discover what mattered to you.

  4. 4

    Publish drafts and changelogs to invite concrete critique; showing the work often yields better guidance than asking from scratch.

  5. 5

    Use short “Today I Learned” style posts to capture specific, practical discoveries rather than comprehensive tutorials.

  6. 6

    Run interactive learning loops through live streams and interviews where guests can be questioned with nuance.

  7. 7

    Reduce risk when going public by rolling out to an inner circle first, then a friendly audience, and only later the full public.

Highlights

Posting imperfect work can be more productive than asking polished questions because it gives others something concrete to correct.
Readwise → Obsidian → Obsidian Publish turns Kindle highlights and lightweight comments into a searchable public vault that others actively use.
The TIL model (as seen in Josh Brown’s GitHub repository) proves that one-liners and small code snippets can be more reusable than broad explanations.
Canary deployment translates cleanly to personal publishing: inner circle feedback first, then early access, then full release.
Writing a book in public (Doing It in Public) extends the same feedback-driven learning loop into a longer-form project.

Topics

Mentioned