I used to have a notes app filled with random code snippets, helpful Stack Overflow links, and those "oh wow I didn't know that" moments. They lived in silos—scattered across my Notes app, bookmarks, and GitHub gists. When I'd encounter the same problem months later, I'd waste time re-discovering the solution instead of remembering I'd already learned it.
Then I started a TIL blog. And it changed how I learn.
The Magic of "Today I Learned"
The TIL format is beautifully simple: capture one meaningful insight from your day as a developer. It's specific enough to be useful but brief enough that you can document it in five minutes. No pressure to write a 2,000-word tutorial. Just: what did you learn, and why does it matter?
The format exploded in popularity because it works. Developers started sharing TILs on GitHub repositories, personal blogs, and Twitter threads. There's something satisfying about the ritual—ending your day by writing down what stuck with you.
But here's what I discovered: the real value isn't just in sharing. It's in building.
Building Your Personal Learning Archive
Every TIL you write becomes part of your personal knowledge base. That regex pattern you mastered? That database optimization trick? The unexpected behavior of JavaScript closures? They're all documented. Dated. Searchable.
Six months later, when you hit a similar problem, you don't have to re-learn it. You search your TIL archive. You find exactly what you discovered before, in your own words, in the context you learned it. No Stack Overflow rabbit holes. No forgotten details.
I started tracking my TILs by technology using tags—#JavaScript, #TypeScript, #React, #DevOps. Now I can see my learning trajectory. What technologies have I explored? What patterns keep appearing? What gaps exist in my knowledge?
It's the difference between learning passively and learning deliberately.
Learning in Public (Without the Pressure)
One of the best parts about sharing your TILs publicly is that you're not claiming expertise. A TIL is inherently humble. You're not writing "Here's How to Master Async/Await"—you're saying "Today I finally understood how async/await works" or "TIL you can use Promise.all() like this."
That permission structure is powerful. You can share half-baked ideas, unexpected discoveries, and even mistakes without feeling like you need to be an authority. Some of my best TILs have come from "I was confused about this, and now I'm not" moments.
And the side effect? Other developers find your TILs and learn too. You're teaching without realizing it. Someone googles a specific problem, finds your TIL, and saves themselves an hour of debugging. That's real impact—not through a polished tutorial, but through authentic, practical learning shared in real-time.
Why Jottings is Perfect for TILs
When I built Jottings, I was thinking about exactly this use case. TILs need a home that's:
Simple to publish: No markdown setup, no deployment process. You should be able to capture a learning moment without friction. Open Jottings, write it, it's published. Done.
Tagged and organized: As your TIL archive grows, you need to find things. Tags let you slice your learning by technology, topic, or area. #TypeScript, #Performance, #Testing—all instantly browsable.
Permanently archived: Unlike tweets (which get lost), TILs should live forever. Your future self will thank you when you need that knowledge again.
Minimal and distraction-free: TILs aren't about design or presentation. They're about the idea. Jottings' clean, minimal interface gets out of the way so you can focus on the insight, not the formatting.
Shareable and discoverable: You can share individual TILs on Twitter, Slack, or in team channels. People can find your learning. And if you add a custom domain, it feels more like your knowledge base than a generic platform.
The TIL Format That Works
Here's the structure I use for most of my TILs:
One-liner opener: What's the insight? "TIL that JavaScript's Array.flat() accepts a depth parameter."
The context: Why did you learn this? "While refactoring deeply nested array manipulation, I discovered..."
The example: Show the code or the pattern. This is the meat of the TIL—concrete, copyable, useful.
The "so what": Why does this matter? "This means I can simplify nested array destructuring" or "This saved me from writing a recursive function."
Sometimes a TIL is just a link with context: "TIL about this technique for CSS containment" with a brief explanation. Sometimes it's a code snippet with a line of explanation. There's no formula—just capture the learning while it's fresh.
Making It a Habit
The key to building a useful TIL archive is consistency. I aim for one TIL every few days—not forced, but intentional. At the end of a coding session, I ask: "Did I learn something I might forget?"
If yes, I write it down. Five minutes of writing saves hours of re-learning.
Some days I write three TILs. Some weeks I write none—I'm just executing, not discovering. That's fine. The practice isn't about hitting a number; it's about capturing the moments when learning happens.
Over time, something interesting happens. You start noticing things more. You're mentally cataloging insights because you know you'll write them down. Your learning becomes more intentional. You're not just accumulating experience—you're actively mining it for insights.
Your TIL Journey Starts Now
If you're a developer who wants to learn more deliberately, share authentically, and build a personal knowledge base you'll actually use, TILs are the answer.
And if you want a simple, distraction-free home for your TIL archive—a place where your learning is organized, searchable, and yours—Jottings is built exactly for this. No complex setup. No unnecessary features. Just you, your insights, and a record of everything you've learned.
Start today. What did you learn? Write it down. Your future self will thank you.
What TILs have shaped your development journey? Share your thoughts—or your learning—on Jottings.