
Blog Meets MCP: AI Agents Maintain Content
How this blog connects to AI agents via MCP/OpenAPI — motivation, workflow, and reflections, without manual layout work.
Read more
Eleven at night. I hand an agent the third task of the day: rewrite this project's deploy script, and hook up the logs while you're in there.
This time is mine: my own projects, nobody setting me a deadline.
In the morning the task is done, the code is waiting for review, and yesterday's idea is a page I can click.
Two years ago a day like this wasn't possible for me.
What changed isn't my ability. It's the marginal cost of turning an idea into something that runs.
AI has improved faster than the way I work. And the job description should change with it: spending your attention on code and algorithms alone is no longer enough.
Most of these appeared in the last month:
The only long-running one is that last item: on and off for the better part of a year. Everything else is from the past month.
They share one starting point: my own need.
Not a request from someone else, and not a product plan drawn up in advance — just a specific moment where I thought "this needs a thing that solves it". One because I wanted bookkeeping that fits how my household actually works, one because I couldn't be bothered syncing photos by hand, one because I wanted deployment at home to be a single click.
Writing, deploying and maintaining are all me, on my server and a small machine at home. No product manager, no roadmap, no requirements review. The person asking and the person building are the same person.
Used to be, the first reaction to a need was to search: is there something off the shelf? An app for bookkeeping, cloud storage for photos, somebody else's compose file for the home server.
Now the first reaction is: I'll write one.
Not because third-party software is bad, but because with AI, building it myself is far quicker. All I have to do is sort out my own requirements — what goes in, what comes out, how I'll actually use it every day — and AI carries most of the work from there.
Building it yourself used to mean three days on scaffolding and a weekend on the edges. Now the scaffolding takes an hour or two, and the time saved goes into thinking the requirement through.
And what I write has exactly the shape I need. No extra buttons, no "upgrade to Pro", no redesign out of nowhere.
The cost is that maintenance is mine too. But that's what building it yourself means: you skip the talking-to-people part, and you take on the reading-it-later part.
"Development speed multiplied" isn't quite right. A better description: the distance from idea to usable went from "a weekend" to "an evening".
Before, an idea would sit in my head for three months, because I knew implementing it would eat every spare hour. Now I just start — build it, see if it's any good, throw it away if it isn't.
That list above is the evidence: most of it built within the past month, every one of them starting from "I want to use this".
There's a side effect: my ideas multiplied rather than shrank.
It used to be "no time to build it". Now it's "queued". And the queue got longer.
If you asked me to sell any of this, honestly, I haven't thought it through for a single one.
There are countless bookkeeping apps; photo sync is a basic feature of cloud drives; plenty of people track their commutes. I build these because what I need isn't "a bookkeeping product" — it's "a way of keeping books that fits how my household actually works". That distinction sets the scope: no multi-tenancy first, no permissions model first, no help docs first.
So I'm not thinking about market fit at all, and I'm in no hurry to turn any of it into a product. Will one of them grow outward some day? Who knows. But right now the motive is clean: I had a specific problem, and I built a specific answer.
This is the part I'm least comfortable with.
My evenings split roughly like this: sit down after dinner, describe a requirement to an agent, review what it wrote, patch what it missed; one task finishes, the next one starts.
I'm not writing code. I'm queueing ideas, then grading the homework AI hands in.
And I can't see this ending. The smoother the tools get, the more ideas I have; the more ideas, the longer the queue. The efficiency gains didn't buy me free time — they bought me throughput.

I used to worry "will AI replace me". Now my question is "how much of my life do I want to spend directing AI".
The things people fought about for years — React or Vue, Next or Nuxt, Prisma or Drizzle — no longer matter to me.
Not because I found the answer, but because the criteria changed.
Choosing a stack used to mean three things: am I familiar with it, is the community big, can I hire for it later. Now it's two: which one is AI better at, and which one deploys with less friction.
If an agent has more training data on a framework and gets it right first time, I use that framework. If an approach needs two fewer config files to deploy, I use that approach. Personal taste? It steps aside.
This isn't capitulating on craft. It's a change in the division of labour: when the marginal cost of writing code approaches zero, "I like it" stops being a serious argument.

The old growth path was clear: faster algorithms, more elegant code, deeper knowledge of one technology.
All three are losing weight — not because they stopped mattering, but because they stopped being the bottleneck.
None of this is a gap in AI's ability. The opposite: give it a clear enough requirement and it does better than most people. What's scarce is the person who can make the requirement clear — who will use this, where the boundary is, what should be hidden. That part AI can't do for you.
None of the above means architecture stopped mattering. The opposite.
On the very day I wrote this piece, I shipped four fixes to my own platform in a row:
/zh/zh/a/...
The common thread: every local piece looked right. What was wrong was the relationship between them.
AI is very good at locally correct code, and it is not responsible for the whole. Ask it to add a field and it adds a field; ask it to add a list block and it adds a list block. Nobody decides who owns the container, who adds the prefix — and six months later you're standing in a swamp.
So architecture hasn't devalued; it has appreciated. It used to be that you were responsible for your own code. Now you're responsible for a pile of code that all looks correct.
AI made writing code cheap and maintenance expensive.
One in the morning. The agent finishes its last task.
I think about the things I abandoned before: an idea that sat in a notes app for two years, a project whose scaffolding I finished and then never opened again, a small tool that stopped a third of the way in. None of them were unimportant. Coding just took too long — scaffolding, edges, one change pulling three other things apart — and the enthusiasm never survived until the thing worked.
That distance is mostly gone now. An idea moves from "is it worth doing" to "let's try it tonight". If it isn't good, change it. If changing it doesn't work, rewrite it. A rewrite costs an evening or two, and polishing no longer costs much at all.
So for me, AI didn't change how fast I write code. It changed the odds that an idea survives.
Tools turn ideas into engineering. Engineering still needs someone to answer for it — that's me. But at least now, it has a chance to be finished.
Related Posts

How this blog connects to AI agents via MCP/OpenAPI — motivation, workflow, and reflections, without manual layout work.
Read more
Learn how to resolve file structure issues in DevOps pipelines for Windows Service applications based on .NET 8.0 by compressing and extracting build artifacts.
Read more