How Reading Improves Your Writing Skills

I spent years chasing the myth that writing well is about following rules—grammar checkers, style guides, endless drafts—until I stumbled on the one thing that actually works. The best writers I know didn’t learn from courses or coaches. They read. Obsessively. Not just for research or leisure, but as a form of training. They turned reading into a gym for their writing muscles, reps and all.

It’s not about copying styles or mimicking voices, either. It’s about absorbing rhythm, structure, and the thousand tiny decisions that make prose sing. You want to write tighter sentences? Read Hemingway. Need to build worlds in a few words? Pick up Le Guin. The more you read, the less you think about writing—because the tools become instinct. And that’s the real hack: writing well isn’t about thinking more about how to write. It’s about doing more of the thing that feeds it.

Technical Overview

There’s no real blueprint for building a technical blog post—no single correct sequence of steps that guarantees a readable or useful result. The tools are just tools, the languages are just languages, and the platforms are just platforms. What matters is how you arrange them, and the arrangement isn’t something you can copy from a template. Every writer’s path to creation is different because every topic demands a different shape: a deep dive into observability needs examples of actual queries, while a discussion of deployment strategies benefits from concrete YAML snippets. The lack of a blueprint isn’t a bug—it’s the point. Standardization here would be like insisting on a specific order of operations for writing a novel: useful as a thought exercise, but ultimately artificial.

Take syntax highlighting, for example. It’s not just about making code look pretty—it’s about making it scannable. Poor highlighting turns a 12-line snippet into a wall of text where the reader has to squint at keywords to understand structure. Good highlighting does the opposite: it guides the eye, signaling where loops begin and end, where function calls sit relative to variable assignments. The difference between good and bad highlighting often comes down to a single decision—whether to color local variables differently from function names, or to ignore the distinction entirely.

Then there’s the question of code placement. Including a block of code isn’t decoration; it’s proof. A reader shouldn’t have to trust that a claim like “the query runs in under 50ms” is accurate—they should be able to run it themselves and see the results. That means the code isn’t just illustrative; it’s verifiable. Which brings up another complication: the code has to be reproducible. If the example relies on a specific version of a library, or a particular configuration file, that needs to be spelled out. It’s not enough to write “install the dependencies” without showing the exact command or the exact contents of a requirements file.

Even when the code is correct, it can still mislead. A benchmark is only as good as the environment it runs in, and a performance claim without system specs is meaningless. A 100ms query might look fast in a local environment with warm caches, but completely collapse under real load. The technical writer’s job isn’t to bury those caveats under marketing language—it’s to state them plainly.

Industry Impact

I don’t know how to feel about a tool that promises to kill billionaires—especially one that delivers that headline with the aesthetic of a meme stock pitch. The joke lands, but only because the audience already knows what they’re getting: a performance of transgressive energy, not a serious economic proposition. That’s fine for entertainment, but it masks something more interesting: the way this framing turns critique into product, and dissent into a brand. It’s less a tool than a stunt, and stunts rarely outlast the hype cycle.

What sticks with me isn’t the provocation—plenty of writers lean into it—but how the community reacts. The sharpest critiques aren’t about the tech or even the politics, but about the writing itself: the laziness of recycled tropes, the over-reliance on AI-generated fluff, the assumption that shock equals substance. That’s fair. Bad writing hides behind bad politics, and vice versa. But there’s a quieter tension beneath it: the idea that the most vital prose can’t exist without an edge of cruelty, as if abuse is the only proof of authenticity. That’s a dangerous myth, one that conflates literary violence with moral clarity.

Where this really matters is in the feedback loop. If people keep rewarding this—buying books, sharing links, amplifying the spectacle—we’re training ourselves to value provocation over precision. That’s a slippery slope. I’d rather see writers focus on what they can say that hasn’t been said before, even if it’s quieter, messier, or less photogenic. The real work isn’t killing billionaires; it’s building something that outlasts them.

Will this version of the tool last beyond the next cycle of outrage? Or is it just another ephemeral stunt, designed to disappear into the noise?

Conclusion

Five years ago, we were told that reading 300 words a day would rewire our brains. Now the benchmarks have jumped to 1,000 words an hour—not because our neurons evolved faster, but because someone ran the A/B test and found the metric that keeps the scroll moving. I still don’t know whether those extra 700 words are teaching me something or just teaching me to tolerate noise.

The books I’ve shipped these last two years weigh in at roughly 200,000 words total. That’s eight hours of audio, or two solid workdays if you read without blinking. Yet the stack beside my desk has more half-finished paperbacks than completed manuscripts, because somewhere between the sixth chapter and the footnote marathon I remember that I also need to run a cluster, debug a pipeline, and occasionally sleep. Maybe the real literacy crisis isn’t the amount we read, but the fact that we keep treating attention like a renewable resource.

Still, when the build fails at 2 AM and there’s no Stack Overflow snippet in sight, the dog-eared manual on the shelf beats the GitHub repo every time. I’ll keep turning pages—not because some algorithm says so, but because the last engineer who trusted autocomplete to write production code left us with 3 million lines of undocumented regret.