I Built a Document Formatter in 2 Hours to Stop Wasting Time
There's this moment that happens every time I write something I want to share. I finish the piece, feel good about it, and then... the dread sets in. Because now I have to post it.
Not just post it once. Post it five different ways.
LinkedIn wants that professional polish with double line breaks and a 3,000 character limit. Twitter needs it threaded if it's long, with each tweet staying under 280 characters. WhatsApp formatting gets weird on mobile if you don't manually add those extra line breaks. Email needs a proper greeting and signature. Instagram wants it optimized for that preview text and maybe some hashtags.
Same content. Five different formatting requirements. Every single time.
And here's the thing that kept getting me: I'd spend 20 minutes writing something thoughtful, then another 5-7 minutes just... reformatting it. Copy-pasting, manually adding line breaks, counting characters, splitting paragraphs, threading tweets.
It felt absurd. Like spending time solving a problem that shouldn't exist.
The Problem I Kept Running Into
I write a lot. Blog posts, thoughts on technology, reflections on building things. And I want to share those ideas across different platforms because different people consume content in different ways. Some folks are on LinkedIn, others prefer Twitter, some just want an email newsletter.
But each platform has its own quirks. LinkedIn's professional tone means I want those clean paragraph breaks for readability. Twitter's character limit means I need to think about natural breaking points and thread structure. WhatsApp's mobile rendering means I need extra spacing or everything mushes together. Email needs that formal structure with a greeting and closing.
I tried keeping notes about each platform's requirements. I built little mental checklists. "Okay, for LinkedIn remember to add the extra line breaks. For Twitter, find natural points to split at 280 characters. For WhatsApp, add those mobile-friendly breaks."
But every time I'd sit down to share something, I'd forget a step. Or I'd get the Twitter threading wrong and have to delete and repost. Or I'd paste into LinkedIn and realize the formatting looked terrible and have to manually fix it.
It was the kind of small, repetitive friction that shouldn't matter. But it added up. Five minutes here, seven minutes there. And more importantly, it made sharing feel like a chore instead of something I wanted to do.
I found myself sometimes just... not sharing things because I didn't want to deal with the reformatting hassle. Which is ridiculous, right? Having good content and not sharing it because the logistics are annoying?
The Moment Something Clicked
I was reformatting a blog post for the third time in a week when it hit me: this is literally just rules. Platform-specific rules about line breaks, character limits, and formatting conventions.
Rules are exactly what computers are good at.
Why was I manually doing this every time? Why didn't I just... build something that handles it automatically?
I opened a new conversation with Claude and started describing the problem. Not as a grand vision for a revolutionary tool, but just as the annoying thing I was dealing with. "Here's what keeps frustrating me about posting content to different platforms."
Within minutes, we were sketching out what this could look like. A simple text input, platform selection, automatic formatting based on platform-specific rules. Nothing fancy, just a tool that handles the repetitive stuff so I don't have to think about it.
Two hours later, I had a working prototype.
What I Actually Built
The Universal Document Formatter is almost embarrassingly simple in concept. You paste your content, select which platform you're formatting for, and it handles the platform-specific requirements automatically.
For LinkedIn, it adds those professional double line breaks that make text readable, enforces the 3,000 character limit, and gives you a clean preview. For Twitter, it automatically threads your content if it's longer than 280 characters, finding natural breaking points at sentence boundaries so your threads read smoothly. For WhatsApp, it optimizes those mobile line breaks so your message doesn't turn into a wall of text. For email, it adds a greeting and signature template. For Instagram, it helps with preview optimization and hashtag organization.
The technical stack is pretty straightforward: React 18, TypeScript, Tailwind CSS, all built with Vite. Nothing cutting-edge or experimental. Just solid, reliable tools that work well together.
What makes it useful isn't the complexity—it's that it handles the specific, annoying rules I kept forgetting. The Twitter threading logic finds sentence boundaries. The WhatsApp formatter knows mobile rendering quirks. The LinkedIn version understands professional formatting conventions.
I built it using AI-assisted development with Bolt.new, which let me go from concept to working prototype incredibly fast. This isn't because I can't code—I can. It's because I'm learning to use AI as a force multiplier for the parts that don't require deep custom logic.
The character counting, the line break insertion, the platform-specific rules—that's all well-established logic. No need to write it from scratch when AI can generate clean, working code in minutes.
The Real Test: Does It Actually Save Time?
Here's the honest assessment after using this tool regularly: yes, it saves time. But maybe not in the way I initially expected.
The hard numbers: I estimate it saves me about 5-7 minutes per piece of content I share. Multiply that by the 10-15 pieces I share per month, and that's 50-100 minutes saved. Not life-changing, but not nothing either.
But the real value isn't just the time saved—it's the friction removed.
Before this tool, there was always this slight resistance to sharing content. I'd finish writing something and think "Okay, now I have to reformat this for three different platforms." It created a mental barrier, even if it was small.
Now? I paste, click, copy, done. The barrier is gone. I share more freely, which means I share more often, which means my ideas reach more people. That's harder to quantify but probably more valuable than the time savings.
I've also noticed I'm more likely to repurpose content. Got a blog post? Easy to turn it into a Twitter thread now. Have a long reflection? Simple to format it for both LinkedIn and email. The tool makes it frictionless to maximize the reach of content I've already created.
The platform is deployed on Netlify, completely free to use, with security monitoring enabled. I use it almost daily now. And occasionally I'll get messages from other content creators asking about it, which tells me I'm not the only one who found this formatting friction annoying.
What I Learned Building This
Building the Document Formatter taught me something important about product development: the best tools often solve your own problems.
I didn't build this because I thought "content creators need a document formatter." I built it because I was personally frustrated with manually reformatting content five different ways. The fact that other people find it useful is validation, but it wasn't the starting point.
This matters because when you're solving your own problem, you immediately know if the solution actually works. There's no guessing about user needs or running surveys to validate product-market fit. You are the user. If it solves your problem, it works. If it doesn't, you know immediately.
I also learned about the power of AI-assisted rapid prototyping. Two hours from concept to working prototype. That's not marketing speak—that's the actual timeline. This changes the equation for what's worth building.
Before AI-assisted development, I might have thought "yeah, this formatting thing is annoying, but is it worth spending two days building a custom tool?" Probably not. But two hours? Absolutely worth it.
The barrier to going from "this is annoying" to "I have a working solution" has dropped dramatically. That changes what's possible for solo developers and small teams.
Finally, I learned that production-ready doesn't have to mean complicated. This tool uses local storage, not a database. It's client-side only, no backend server. The code is clean and well-structured, but it's not over-engineered. Sometimes the simple solution is the right solution.
Where I'm Still Figuring Things Out
There are obvious ways this tool could evolve. I could add analytics to see which platforms people format for most often. I could build in scheduling features to actually post the formatted content. I could integrate with platform APIs for one-click posting. I could add more platforms, more formatting options, more customization.
But here's what I'm wrestling with: should I?
Every feature I add increases complexity. More code to maintain, more potential bugs, more decisions for users to make. The tool works because it's simple and focused. Adding features might make it more capable but less useful.
I'm also thinking about the open source angle. The code is on GitHub, available for anyone to use, modify, or learn from. Part of me wants to actively maintain and expand it as an open source project. Another part thinks it's valuable precisely because it's complete and stable as-is.
There's also the question of monetization. Could this be a paid product? Maybe. Should it be? I'm not sure. The value it provides is real but incremental. The time it saves is meaningful but not transformative. Would people pay for that? Would I want to deal with payment processing, customer support, and feature requests for a tool this focused?
I genuinely don't know the answers yet.
What This Means for How I Build Things
The Document Formatter represents something bigger than just a formatting tool. It's proof of concept for a different approach to product development.
Instead of spending months building something I think people might want, I can spend hours building something I know I need. If it solves my problem, it probably solves someone else's too. If it doesn't, I've invested hours instead of months.
This is possible now in ways it wasn't even a year ago. AI-assisted development, modern frameworks, simplified deployment—the barriers to going from idea to working product have dropped dramatically.
I'm starting to see my development work differently. Not as "I need to spend months building the perfect version of this product," but as "I can spend hours solving this problem and see if the solution resonates."
The Document Formatter works. It saves time. It removes friction. It's been deployed and used consistently for months without major issues. That's success, even if it's not venture-scale success.
And honestly? That feels more meaningful than building something bigger that nobody uses.
The Question I'm Left With
I keep coming back to this: how many problems am I tolerating that I could solve in an afternoon?
Not big, systemic problems that require massive solutions. Small, annoying frictions that add up over time. Repetitive tasks that follow clear rules. Formatting headaches. Copy-paste workflows. Manual processes that could be automated.
The barrier to solving these problems used to be time and technical complexity. Both of those barriers are lower now. Sometimes dramatically lower.
Which means the real question isn't "Is this problem worth solving?" It's "Why am I still doing this manually?"
I built a document formatter in two hours. It saves me five minutes every time I use it. After a month, it was time-positive. After a year? Significantly time-positive.
More importantly, it removed friction from something I do regularly. Made sharing content easier. Lowered the barrier to getting my ideas out into the world.
That's worth two hours.
So here's what I'm wondering: What are you still doing manually that's just... rules? What friction are you tolerating that could be automated? What small annoyances have you accepted as just part of your workflow?
Maybe it's time to stop accepting them.
Maybe it's time to spend an afternoon building the solution.
About Jeremy
I'm a Connector, Creative, and Tech Futurist focused on making technology meaningful and accessible. I build tools that solve real problems, explore how AI is changing what's possible for individual developers, and share what I learn along the way. You can find more of my work at jeremymckellar.com or check out the Universal Document Formatter yourself.
A Note on AI Collaboration
This article was developed in collaboration with Claude as a thinking partner to help synthesize and articulate my experiences building the Document Formatter. I believe AI tools can amplify our human insights and help us share our stories more effectively—both in building products and in writing about them. The tool I'm writing about was built using AI-assisted development, and this article about building it was refined with AI collaboration. That feels appropriately meta.
Let's Talk
What friction are you dealing with in your workflow that could be solved with a simple tool? What are you still doing manually that bothers you every time? I'd love to hear what problems you're tolerating and whether you've thought about just... building the solution. Share your thoughts in the comments or connect with me to continue the conversation.
Try the Universal Document Formatter: document-formatter.netlify.app
View the code on GitHub: Universal-Document-Formatter Repository