Automating Blog creation, MCP vs Creating own agent

Today we're belly-flopping into the glamorous world of blog post automation — because who doesn’t dream of spending their weekends wrangling markdown, LLMs, and API tokens, right?

Let’s be honest: writing blogs is exhausting, and reading AI-generated "thought leadership" on LinkedIn is even worse. I didn’t want to contribute to the noise — but here i am pretending to create something actually useful. And maybe, just maybe, save myself from typing the same “Here’s how you use a decorator” explanation for the 20th time.

So I built two things. And now, we’re pitting them against each other in a cage match of code and questionable sanity:

1. My Hand-Rolled Agent: A custom-built Python script, fueled by LLMs and sheer willpower, designed to take a blog title, some rough notes, and tags, and spit out a semi-coherent Hashnode post. I even built a whole UI for this monstrosity.

2. MCP (Model Context Protocol): I was going to implement it myself. But i found a opensource implementation of it done very recently by someone who had an awesome portfolio site. Same like mine but on steroids.

For those who don’t know — Hashnode is basically like Medium, but built for developers and, honestly, way better. Custom domains, Markdown, no paywalls, and an actual API? Yeah, Medium could never. This blog site made with Hashnode.

---

1. 💀 My Hand-Rolled Agent

A custom-built Python script, fueled by LLMs and sheer willpower, designed to take a blog title, some rough notes, and tags, and spit out a semi-coherent Hashnode post.

I even built a whole UI for this monstrosity. It’s rough around the edges, but it’s mine(claude). It accepts your blog title, tags, and raw chaotic notes like:

Then it wrangles that input into something that won't get you cyberbullied on Twitter. The backend? FastAPI. The LLM? Gemini. The deploy? Docker Compose. The pain? Immeasurable.

Feast your eyes on the screenshots:

This setup gave me a decent amount of control, and honestly, it felt pretty great to spin up something from scratch. The full thing — frontend, backend, all duct-taped together — is open source at agent-hashnode. It’s fast, it’s messy, and it works.

---

2. 🤖 The Hashnode MCP (Model Context Protocol)

Okay, so here’s where the future slaps you in the face.

I had barely dipped my toes into the whole MCP ecosystem, and suddenly I'm staring into a rabbit hole of possibility. I was going to build my own implementation. I really was. But then I stumbled across an very recent opensource contribution. Shoutout to sbmagar13 for building the actual mcp server.

Now, what is this "MCP" thing?

Imagine your dumb little script from earlier. Then imagine you could talk to it. Like, literally say:

"Hey, create a blog post about FastAPI and Gemini, tag it with 'AI', 'Python', 'FastAPI', and use these notes to flesh it out."

And it does that. Not because you hardcoded anything, but because the LLM running behind it actually understands the task and knows how to call different microservices to get it done.

I spun up a TUI-based MCP client with Cursor (yes, that Cursor), and here's what it looks like:

With just natural language, I can now:

• 🗂 Create folders and files

• 📄 Generate blogs (duh)

• 📝 Edit existing blog posts

• 🧠 Chain tasks like "create blog → upload to Hashnode → tweet it"

• 🧰 Add more servers to automate literally everything

Everything’s modular. Everything’s extendable. I could hook it up to an email server, a Terraform infra manager, even a coffee machine if I wanted. I’m basically living in 2035 now.

Here’s what it looks like when I ask it to publish a blog using the Hashnode MCP server:

No manual API calls. No YAML sacrifices to the CI/CD gods. Just vibes and language.

The full implementation of the Hashnode MCP is at sbmagar13/hashnode-mcp-server. Seriously, check it out. Kudos to the developer

---

🧠 Final Thoughts

I started this project thinking I’d hack something together, automate a few boring blog posts, and call it a day. But what I discovered was a fundamental shift in how we build tools.

Originally, I just wanted to continue my Advanced Python blog series. I had learned some cool new tricks and figured it was time to share. But the idea of sitting down to write all those blogs — with proper code snippets, formatting, explanations — sounded exhausting. And of course i would be using LLM anyway.

So I thought, “Why not automate the whole thing?” That’s when I stumbled across MCP. I didn’t know much, but figured I’d learn it and use it to generate and publish blogs. Of course, being me, I ended up starting coding immediately and buildt my own agent from scratch.

...which, hilariously, wasn’t MCP at all.

But then I looked into the real MCP — and man. It looked extremely promising. On my journey to learn MCP and automate my blogs. Within six hours I had built three repos, written five blogs, and even spun up my own custom MCP client from scratch. I don’t even know what code has been written at this point(thank you cursor). It just happened.

The scale at which we can build things now is unprecedented. This isn’t about speed anymore — it’s about lightspeed(okay this is lame).

The classical method? It works. You build parts, wire them together, and maybe—just maybe—you get something that saves you 10 minutes a week.

But MCP? It’s not just code. It’s conversation. It’s building with your tool, not just for it. It’s not magic — it’s just damn good architecture powered by LLMs that actually understand how to collaborate with APIs.

If you’re a developer, go try this. Stop gluing together scripts. Start treating your tools like collaborators.

The world is changing. Fast.

And honestly?

Bye bye coders. Hahahaha.

References

Code

1. MCP Terminal Client

2. Custom Hasnode AI agent

3. Hashnode MCP server

Blogs Generated

1. Python descriptor protocol

2. Python closure

3. Python ___hash___ dunder

4. Franz Kafka Poetry

5. blog generated by very random prompt