The Side Project That Quietly Started Writing My Docs for Me

It started as an excuse to avoid writing docs.

I had just finished a sprint that left my brain feeling like spaghetti code — tangled, messy, full of weird dependencies.

The feature was working.

The code was clean.

The documentation? A blinking cursor on an empty page.

So instead of writing it, I told myself I’d "just tinker" with a little automation idea I’d been playing with on weekends.

The Documentation Problem Every Dev Knows

Docs aren’t hard in theory.

They’re just… slow.

Especially when you’re context-switching between writing for humans and thinking in code.

I’d write two sentences, jump back into my IDE to check a function, realize I forgot to push a commit, and — 40 minutes later — still have no docs.

The result?

Important details lived in my head until they either got lost or became a problem for Future Me (or worse, Future Teammate).

The "Not Really Related" Side Project

My side project was simple: a script that scraped my own commit messages and code comments to create a rough changelog.

It wasn’t supposed to be for docs.

It was just a way to track what I’d done without digging through Git history.

One Saturday, I decided to feed that changelog into Crompt AI, just to see what would happen.

I dropped it into the Document Summarizer.

Thirty seconds later, I had a readable summary of the update — in plain English.

The "Wait, This Works" Moment

It wasn’t perfect.

It missed some context, used a few generic phrases.

But it was 90% there.

For the first time, writing docs didn’t start from a blank page.

It started with something that already made sense.

So I kept going:

• Ran my inline comments through the Improve Text tool.

• Expanded vague bullet points with the Expand Text tool.

• Polished the final version with the Grammar and Proofread Checker.

A task I used to avoid for days was now a 30-minute review process.

Integrating It Into My Workflow

I set up my side project to:

1. Pull commits and comments from the repo.

2. Auto-format them into a single Markdown file.

3. Pipe that into Crompt via the Document Summarizer.

4. Give me a clean draft to edit.

Now, when I wrap up a feature, my docs are already half-written by the time I think about them.

Why It Works So Well

It’s not because the AI magically "knows" my project.

It’s because it works with the data I’m already producing while coding.

The real barrier to documentation isn’t writing skill — it’s starting.

Once you’ve got a first draft, editing feels easy.

That’s why this works:

It turns "nothing" into "something" before you even open the docs folder.

The Bigger Lesson

I didn’t set out to solve my documentation problem.

I just scratched an itch for tracking commits.

But side projects have a way of solving real problems you didn’t plan for — especially when you combine them with the right helpers.

In my case, the helpers were:

• Document Summarizer — for turning commits into coherent paragraphs.

• Improve Text — for making technical notes sound human-readable.

• Expand Text — for fleshing out brief points.

• Grammar and Proofread Checker — for a final polish.

For Any Dev Who Hates Docs

If you’re a developer who treats docs like the last boss fight in a game, try this:

1. Automate your input — Pull from commits, code comments, or issue tracker notes.

2. Summarize before you write — Let a tool like Document Summarizer give you the first draft.

3. Iterate instead of invent — Use Improve Text and Expand Text to evolve the draft.

4. Polish last — Clean it up with the Grammar and Proofread Checker.

Looking Back

That blinking cursor doesn’t scare me anymore.

When I open a new doc file, it’s already full of words — my words, just organized and cleaned up.

What started as a tiny weekend script now quietly does the part of my job I used to postpone for days.

And honestly?

It’s the only "automation" I’ve built that’s made my past self and my future self happy at the same time.

Lingering thought:

Sometimes the best productivity tool isn’t the one you planned to build — it’s the one that solves the problem you didn’t even admit you had.

I Write about tech the way some people write love letters — curious, sharp-eyed, and allergic to jargon. Covers the tools, trends, and ideas shaping tomorrow, with the goal of making them clear enough to explain over coffee.