Numeric Citizen I/O — A Blog About Blogging

The Numeric Citizen Digital Ecosystem — Edition 2026-04

Mon, 27 Apr 2026 17:38:17 -0400

Today, I’m excited to share my latest digital ecosystem update, previously known as “The Numeric Citizen Content Creator Workflow”. The diagram sports a new title: “The Numeric Citizen Digital Ecosystem” to better reflect its scope: to enumerate services and apps at the center of my digital presence. It was entirely rebuilt in Apple Freeform, leaving Apple Keynote behind. Freeform is a joy to use; it’s much more flexible and powerful than Keynote, too. The content was also expanded to include a new set of tools I have built over the last few months since publishing the previous update. Let's dive in for all the details.

The entire ecosystem diagram was rebuilt from the ground up. Full resolution version available here.

At a high level, both Micro.blog and Ghost remain the two hosting and publishing pillars for most of my *.numericcitizen.me websites, while a few other websites, like my Ko-fi page and my new about website, Who Is Numeric Citizen, are hosted elsewhere. On the diagram, my websites are positioned on the left and in the top-left portion.

As you might notice, a lot has happened since my last update. Thanks to Claude AI and Claude Code, I made a major shift toward web app to meet two fundamental needs: a brand new bookmark manager (replacing AnyBox), and a lightweight RSS reader that integrates with my bookmark manager. Together, they support my reading workflow and help me produce the Ephemeral Scrapbook newsletter. See both web apps in this YouTube video.

My custom-built RSS reader web application

What’s in, what changed since last fall

AI is now playing a more prominent role in my digital ecosystem since the beginning of 2026. It’s mainly used for vibe coding, maintaining my web applications, and content summarization. You’ll see little light bulbs (💡) in the diagram; they indicate where AI summarization is involved. Anthropic’s Claude AI replaced OpenAI’s ChatGPT in all my workflows. Plus, Claude AI and Claude Code enabled many new possibilities for helping me build small digital services and web apps for my personal needs. It’s something I couldn’t have imagined a year ago.

Claude Code’s main window with some of my projects on the left sidebar and the DIFF view shown on the right

Another milestone was to replace IFTTT with n8n automation. It’s a major upgrade in functionality and usability. My n8n instance is running on the Digital Ocean hosting service, inside a pre-packaged “droplet” with 1 GB of RAM and 10 GB of disk space for $6 a month. Digital Ocean provides a one-click install of n8n which really made a difference in selecting Digital Ocean as a hosting service. I created more than a dozen automations, far more complex and useful than what I could build with IFTTT. Claude AI was also involved in optimizing many n8n workflows. It was possible because n8n supports the MCP endpoint that is exposed to Claude AI. In the following table, I present a summary of my n8n automation workflows. As you will see, Discord is a new entry, as it provides a custom server to receive n8n workflow outputs and some status reports from Tinylytics. Also good to know: all my n8n workflows are automatically documented in a Craft document, thanks to Claude Code, which connects to both the n8n and Craft backends. To get a well-structured documentation, I created a Claude Skill.

A portion of an automation workflow shown in the n8n canvas

My automated n8n workflows

Here’s a list of utilities running as n8n workflows on my self-hosted DigitalOcean instance.

API Credit Health Check — Pre-flight check on Anthropic credits; alerts Discord if depleted
Today's Forecast — Pulls weather data into the Craft daily note
Tinylytics Insights — Injects site analytics summary into the Craft daily note
Apple Daily News — Fetches MacSurfer headlines into the Craft daily note
Setup Craft Daily Note — Creates the day's 8-section journaling scaffold in Craft
Anthropic Daily Cost Report — Posts 7-day and 30-day AI spend breakdown to Discord

Example of automatically propulated Craft Daily note, thanks to n8n automation.

RSS & News Aggregation

A few workflows are used for content processing in the context of news consumption and Micro.blog timeline processing.

RSS Daily Summary — Aggregates RSS feeds and delivers an AI-summarized digest
Micro.blog Timeline Highlights — Summarizes Micro.blog activity via Claude
Apple News Flash Alerts — Real-time Apple news alerts from RSS
Apps & Services Release Highlights — Monitors release notes feeds for notable updates

Content & Publishing

Other workflows for supporting my content creation include:

Craft → Ghost — Two workflows (specific and generic) push Craft documents to Ghost as drafts
Ghost Publish Proxy — Triggers final publication on Ghost via webhook
Craft Fetch Proxy — Fetches Craft document content on demand for downstream processing
Poke to Craft / Peek at Ghost — Manual/chat-triggered utilities for quick content inspection

Newsletter & Email

A special workflow automation is processing email summarization on demand: simply forwarding an email to a dedicated Gmail account and after a few seconds I’ll receive a summary on my Discord server.

Email Summarizer — Polls Gmail every minute; summarizes newsletters and posts to Discord

Maintenance

Finally, backing up my workflows is a must, just in case something really bad happens on my n8n instance.

GitHub Backup — Backs up all n8n workflow definitions to a GitHub repo every Sunday

The Craft Agents main window

The updated diagram illustrates this: Craft consists of two parts—Craft content stored in the Craft cloud backend and various Craft clients, including the native general-purpose client and Craft Agents. Additionally, Craft now supports MCP and offers a comprehensive set of APIs, emphasizing the division between data storage and client applications. These latest additions to Craft are game changers and enable new use cases.

A few thoughts and observations about Craft Agents, a sort of spin-off of Craft, are worth sharing here. Think about Craft Agents as an orchestrator of AI agents. In many ways, Craft Agents can be compared to the Claude Desktop app. There is a high level of affinity between Craft Agents and Craft, connected via APIs or MCP. Consuming Craft content through Craft Agents is an obvious use case. Yet, I’m still not sure why the team behind Craft is spending so much effort on this, but it’s interesting to follow nonetheless. I’m still looking for clear use cases for it, hence the yellow dot (🟡) on its icon in the diagram. There are a few aspects of the app’s design and structure that I don’t like. I don’t like using the task manager to organize conversations. I don’t think task management belongs in this app. Plus, Craft Agents is a very hungry consumer of AI credits. It’s a major concern unless you subscribe to the highest tier of any AI provider (OpenAI, Anthropic, etc.). It’s worth noting that Craft also offers an assistant working inside Craft itself.

Also added to my digital ecosystem is CleanShot Cloud for hosting publicly shared screenshots or short screen recordings. I use that to share bugs or feedback. CleanShot X is sort of the client to CleanShot Cloud and is the best Mac utility you can get if you tae a lot of screenshots.

One last automation that prevented me from closing my IFTTT account was the process of automatically archiving my publications in DayOne. This process was briefly described in this blog post. Each time I share a blog post or an article, it is saved in DayOne. Micro.blog added a send-to-DayOne feature, which was the last needed nail in the coffin of IFTTT. It was such a relief.

Speaking of Micro.blog, I created a new website for sharing automated blog post digests on a monthly basis. Most of the process is supported by the use of AI summarization. It’s not fully automated but very effective. Each month I send my Micro.blog postss digest to Craft fo later processing using Craft Agents. The process takes less than 15 minutes to complete. I know there is a potential for a fully automated process. It’s on my todo list.

What’s out since the last update

Chillidog Web Hosting is out (the service hosting the Who Is Numeric Citizen website). It was replaced with Realmac Software Elements’ hosting solution. You can read the doc here. The transition was seamless. I prefer integrated solutions, which Realmac is now offering. Plus. Chillidog was purchased last year by Exact Hosting, and the purchase has been reported to degrade customer service.

Last fall, I added the ChatGPT Atlas browser to my ecosystem, but I removed it after switching to Claude AI. OpenAI Atlas was mainly used for summarizing articles, but now I do this within the Claude Desktop app. I still prefer using the ARC Browser, even though it might eventually be discontinued. The new browser, Dia, could take its place, but I’m interested to see how things unfold. Dia appears to require a Pro subscription to enable AI features in the browser. At $20 a month, I’ll pass.

Gone is Google News for cross-posting from Micro.blog. It never took off. Also gone is AnyBox, the very well-done bookmark manager available on all Apple platforms, but not available on the web, like Raindrop.io. I never liked Raindrop.io, so I built my own bookmark manager as a web-only app. It’s one of my new custom-built web apps.

Finally, the numericcitizen.io domain will be retired when it expires later this year, and the content hosted on a dedicated Craft subscription has already been moved to my main Craft subscription, helping me reduce costs. The meta.numericcitizen.me is taking over (my previous content was migrated there during 2025). Some of my content was also simply removed from public access.

My newly redesigned metablog as seen in dark mode

Still pondering about these

You’ll find yellow dots on the diagram which points to services or apps that I’m reconsidering. Let’s review a few of them.

Plausible vs Tinylytics: I use two web analytics. Plausible has been around in my ecosystem since I left Google Analytics. Then came long Tinylytics and I wanted to support its developer plus it provides a great design compared to Plausible. Yet, I have a lot of historic data in the latter. Plus, I started using Tinylytics APIs to feed one of my workflows who inject data inside Craft daily notes and dashboard web application. I could replace this with Plausible’s APIs but I don’t feel it’s worth the effort.

Things 3, a popular and highly regarded task manager, is currently being reconsidered. I like managing my to-dos, but I don’t have many. If I want to eliminate Things 3, I could switch to Craft’s basic task management, but it’s quite limited. For now, my most likely option is to create my own app, much like I did with my RSS reader or bookmark manager. However, I’m not in a hurry to switch away since it doesn’t require a subscription, giving me plenty of time to decide and develop a replacement.

Ulysses is another case where I’m pondering its long-term usefulness. If I can post to Micro.blog or Ghost directly from Craft (using my custom-made n8n workflows), why should I continue paying for this app? The next renewal is a year from now.

Finally, my Flipboard account hosts a magazine that pulls content from my main website via its RSS feed. I have 8 followers, apparently. I never get any reactions or comments from this place. The bigger question: is Flipboard still a thing these days?

Risk management

In this edition of the diagram, I included red dots (🔴) to indicate potential disruption risks. For example, Anthropic recently adjusted Claude's credit consumption, leading to a fivefold increase in the number of credits needed to perform the same task; something I've noticed too. Additionally, Anthropic conducted an experiment in which new subscribers could access Claude Code only if they chose the Max subscription tier at $200 per month. Although they quickly reversed this change, it raises the concern that they might eliminate the $20 plan altogether. If that happened, I could face serious difficulties and might stop maintaining my web applications built with Claude Code. Vercel is another risk potential: I’m using the free tier, which is rather generous. If they decided to remove this free tier, I would have to reconsider my position: either drop my web application or accept paying the monthly price they charge.

Concluding thoughts

This evolution reflects a fundamental shift in how I approach my digital life. By embracing AI assistants like Claude and building custom tools tailored to my specific needs, I've moved away from cobbling together disparate services toward a more cohesive, intentional ecosystem. The transition from automation platforms like IFTTT to n8n, coupled with the ability to code solutions with Claude Code, has given me both flexibility and control—rare commodities in the world of Software-as-a-Service.

The introduction of AI summarization across my workflows has transformed how I consume information, while the consolidation of my web presence under fewer, better-managed domains simplifies my digital footprint. Yet this ecosystem remains dynamic and somewhat fragile, dependent on the sustained availability of key services and the pricing decisions of AI providers. The risk management considerations I've outlined aren't just technical footnotes—they're essential guideposts for maintaining digital independence in an increasingly interconnected world.

As I continue to iterate and refine this ecosystem, the principles remain constant: intentionality, control, and the ability to evolve. The next edition will likely bring even more changes, but I'm optimistic that the foundations I've built will prove resilient enough to adapt to whatever comes next.

Previous update to my digital ecosystem can be found here.

Solving Broken Images When Exporting Craft Documents

Sat, 25 Apr 2026 13:27:03 -0400

The Problem

When exporting articles from Craft to Ulysses and Micro.blog, images referenced by temporary URLs quickly become broken links. Craft hosts images with public URLs that expire within days, leaving your published posts with missing images. This automation workflow solves that problem by re-hosting all images on Micro.blog before publishing.

How It Works

The workflow is triggered when you request to publish a Craft document to Micro.blog. Here's what happens behind the scenes:

A request is send in Claude with the article title to publish
The n8n automation searches my Craft space and uses a scoring algorithm to find the exact document (preventing false matches from body text mentions)
The document's content is converted from Craft's block format into clean HTML, preserving headings, lists, formatting, quotes, code blocks, and more
The workflow scans for all image URLs pointing to Craft's backend hosting
Each image is downloaded from Craft and immediately re-uploaded to Micro.blog's permanent media storage
All image references in the post are updated to point to the new, stable Micro.blog URLs
The article is published as a draft to Micro.blog for review before going live, which is a manual process

Key Technical Features

Smart Document Matching

The search algorithm scores results by how closely the document title matches the request. Exact matches score 100, partial matches score lower, and body-text mentions are heavily penalized. This ensures I get the right document even if multiple articles discuss similar topics. The search is done via Craft API endpoint.

Rich Content Support

The conversion preserves all the formatting: paragraph styles, heading levels (h1–h4), bullet and numbered lists, blockquotes, task checkboxes, strikethrough text, code blocks, horizontal rules, and rich link bookmarks. Consecutive list items are automatically grouped into single lists.

Graceful Image Handling

If an image fails to upload (for example, unsupported formats like AVIF), the system keeps the original Craft URL in your post rather than failing entirely. This ensures the article publishes even if one image has issues.

Manual Review

All posts are created as drafts in Micro.blog. I can review the final result, check that images loaded correctly, and make edits before publishing it live.

Workflow Specifications

Trigger: Webhook at craft-to-microblog (available in my n8n instance wirh MCP endpoint enabled)
Input: Simple JSON with the article title to publish
APIs used: Craft's document search and block retrieval, Micro.blog's Micropub standard API
Typical execution: 4–6 seconds (image uploads add ~1.5 seconds)
Output: Draft post URL, preview link, and edit URL from Micro.blog

Why This Matters

This automation fills a gap in the content publishing process. I can craft and organize my articles in Craft, a versatile and attractive writing environment, and then publish them to Micro.blog without losing images or manually fixing broken links. I use a similar method to publish new editions of the Ephemeral Scrapbook newsletter, which relies on a separate n8n workflow to handle Ghost CMS-specific requirements.

Fri, 24 Apr 2026 09:22:57 -0400

Now that I manage all my issues and enhancements in GitHub Issues, I just realized that I could automate many manual workflows on issues closure… many interesting ideas here, like updating the README.md file once an issue is closed by Claude Code. 🤓

Thu, 23 Apr 2026 22:18:53 -0400

I’m not planning to go any further with my Lovable experimentation. The reason? On the free plan, custom domains are not supported. It’s a complete deal-breaker. Plus, the free tier doesn’t provide enough credits to build something meaningful, and you have to wait 24 hours before getting more. Too bad, it was somewhat promising. Pass. 😔 The good thing is that I’m focusing on Vercel for hosting web apps like mine.

Thu, 23 Apr 2026 07:32:29 -0400

Restarted work for maintaining and updating the “Who Is Numeric Citizen” website, now that my 90% of my vibe coding work is completed. See the latest news post for more details.

Sun, 19 Apr 2026 17:14:13 -0400

Just testing something for my next project… for that one, I might try Lovable instead of Vercel… because I want to try different services.

Thu, 16 Apr 2026 21:59:31 -0400

From now on, I will document and track all bugs in my custom web apps using GitHub, instead of relying on checklists in Craft. Centralizing everything isn’t ideal; organizing issues in their appropriate locations is smarter. Additionally, Claude Code will be able to close issues on my request.

Sun, 12 Apr 2026 09:16:49 -0400

Today I went ahead and fully migrated “Who Is Numeric Citizen” website to Realmac Software Elements Hosting instead of Chillidog Hosting service. Here’s why: A) Chillidog was recently sold, and people are already complaining about a decline in service quality. B) What Realmac Software accomplished with Elements in the last year is nothing less than exemplary. They built mature, native web design software for the Mac and a hosting service. I prefer to reward this company for this hard work.

The migration was really simple and took me less than an hour. The service is a bit more expensive but includes more storage and unlimited network bandwidth. This could enable a future option for hosting more photography-related content. Finally, the web service feels snappier, too!

Coming Soon

Thu, 09 Apr 2026 19:20:16 -0400

One of the first things I’m going to do when I come back home is to deploy my new blog visual theme built entirely with Claude Code. It’s ready. I’m anxiously awaiting for the moment I put that project behind. Next, I’ll spend some time on Who Is Numeric Citizen website design and hosting solution (I’m thinking of leaving Chillidog Hosting hosting service to go with Elements’ built in solution instead).

Mon, 30 Mar 2026 20:42:52 -0400

I realized I forgot to clearly state the design goals before starting to build this custom theme for Micro.blog. They became clearer as I progressed and explored how Hugo and Micro.blog work, especially with assistance from Claude AI, and as I encountered various challenges. Here are the goals: a) I want a theme that stands out and doesn’t resemble typical Micro.blog blogs. b) I aim to minimize the use of external plugins, ensuring that all functionality is integrated within the custom theme. c) I want the same theme to be usable on more than one blog (I have two). Stay tuned for more news.

Takeaways From Building a Custom Micro.blog Theme Using Claude Code and Claude AI

Sun, 29 Mar 2026 19:14:16 -0400

Building a custom visual theme for Micro.blog presents unique challenges at the intersection of web design, static site generation, and AI-assisted development. This blog post captures practical insights and lessons learned from creating a custom theme with Claude Code and Claude AI, including key considerations on Hugo compatibility, plugin conflicts, and theme architecture.

Claude AI isn’t well-trained on Micro.blog architecture and dependency on Hugo static website generator. Claude doesn’t make a clear distinction between Hugo’s capabilities and Micro.blog’s unique features.
Plugins are a challenge because they might inject conflicting formatting instructions into your custom-built theme. It’s hard to debug.
Plugins can conflict with each other.
Don’t use the latest Hugo version (0.158) and stay on 0.117 if you use many plugins. By removing low-value plugins, you increase your chance of using version 0.158.
The workflow for updating a GitHub repo hosting your custom theme to the deployment on The process of Micro.blog is tedious because it’s manual and slow, especially for large websites and Hugo rendering engine. Hugo 0.158 could help, unless it conflicts with one plugin that you need.
More than ever: less is more. Keep it simple, and problems will be kept at bay: removing low-value plugins can make a big difference.
Test the website after each plugin removal, force a rebuild of the entire site to cleanup things. It’s slow but it might help debug later.
If a plugin introduces support for smart code in blog posts, after removing that plugin, Hugo will generate errors. These blog posts need to be either updated or deleted.
If the custom-built theme covers a specific design area, like a /photos page, don’t use a plugin touching the same area, prioritize the custom-built theme and skip the plugin. The idea is to have a self-contained custom theme.
Stay away from abandoned-ware plugins.
Prefer adding stuff in the custom theme instead of relying on an external plugin, so the theme is self-contained.
The lower the number of plugins, the better the chance you can use the latest version of Hugo.
Using the custom.css functionality, which helps externalize and override the custom-theme’s styling, speeds up testing different styling options.

Creating a custom Micro.blog theme using Claude AI revealed both the power and limitations of AI-assisted development in specialized ecosystems. While the tools provided invaluable support, the real breakthroughs came from hands-on debugging and understanding the unique interactions between Hugo, Micro.blog, and plugins. These takeaways form the foundation for a more robust theme architecture—one that will continue to improve with future iterations.

I’m still not done with my design. As I progress, you can visit my test blog.

Sat, 28 Mar 2026 14:36:45 -0400

One positive side effect of this custom visual theme that I’m working on is that I’m cleaning up this plugin’s mess on my blog. I have way too many with little added value for the readers.

Analyzing My Installed Plugins

Sat, 28 Mar 2026 13:52:08 -0400

Just finished compiling the list of Micro.blog plugins that my blog is using: 31 in total. Then Claude AI analyzed all GitHub repos to see if there were any potential conflicts. Here’s the complete impact report for all 31 plugins, organized by risk level:

🔴 Avoid / Direct Conflicts with Your Theme

micro-blog-cards-theme — This is a full replacement theme, not a plugin. Installing it would completely override your custom theme. Skip it entirely.

plugin-collections — Injects its own lightbox targeting .e-content img. This directly conflicts with the custom lightbox you built in v0.9.12 (theme.js). Both would fight over the same images. Don’t install unless you remove your lightbox first.

plugin-opengraph-basics — Your theme already has full Open Graph meta tags (added in v0.5.9 in head.html). Installing this would generate duplicate OG tags in the <head>.

🟡 Caution / Needs Attention

plugin-archive-months — Overrides list.archivehtml.html, which would take over the archive page display with its own year/month grouped layout and inline JS. Replaces the theme’s existing compact archive view.

plugin-photos-months — Overrides list.photoshtml.html. Conflicts with your already-installed plugin-all-photos, which also provides that template. Last one installed wins.

plugin-screenshots — Also overrides list.photoshtml.html. Same conflict with plugin-all-photos.

kottkrig/microdotblog-photos-page — Also overrides list.photoshtml.html. Same three-way conflict. Pick only one photos page plugin.

stoot — Its CSS expects CSS custom properties (--gray-*, --white, --black, --link, --text-base) that your theme doesn’t define. Mastodon embeds will render with broken/missing styles. Fixable by adding those variables to style.css.

plugin-post-stats — No dark mode support in its CSS. The stats page cards and Chart.js charts will look visually inconsistent in dark mode. Fixable with CSS overrides.

plugin-bigfoot — Already analyzed. jQuery 1.12.4 (~90KB) loaded on every page, and footnote popover CSS won’t respect dark mode. Set post_separator = "article.h-entry" when installing.

plugin-conversation-on-mb — Adds a “View conversation on Micro.blog” link, but requires manually calling {{ partial "conversation-link.html" . }} in your theme’s single post templates. Your theme already loads Micro.blog’s conversation.js via microhook-after-post.html, which renders the full conversation box. This plugin adds a different thing (a link vs. a box), so they don’t conflict — but it needs a manual theme edit to integrate.

plugin-reply-by-email — Same situation: requires {{ partial "reply-by-email.html" . }} manually added to your single post template. Your theme already has reply.js for native Micro.blog replies. These serve different purposes (email vs. Micro.blog) and can coexist, but need a theme edit.

plugin-reply-on-mastodon — Repository returns 404. No longer exists.

plugin-search-space — Creates a /search-space/ page (different URL from your installed /search/ page). Having two search pages could confuse visitors. Pick one.

Bottom line: The most important things to avoid are plugin-collections (lightbox conflict) and plugin-opengraph-basics (duplicate OG tags). For the photos page, pick only one of: plugin-all-photos, plugin-photos-months, plugin-screenshots, or kottkrig/microdotblog-photos-page.

I’m not sure everything has been analyzed correctly, especially when it comes to photo-related plugins.

Time for a Complete Reset

Sat, 28 Mar 2026 10:30:06 -0400

It’s time for a project status update. I’ve been working hard trying to get the Micro.blog/Hugo engine to make this custom theme work the way I want. It’s not an easy task. I’m starting to think that because Micro.blog is a niche product, even though it is based on Hugo, there are some particularities in the templating system that Claude AI is not well-trained for. Micro.blog plugins make things even more complicated. I’m now at a point where I need to feed all plugin GitHub repositories into my conversation so Claude AI can fully understand what each plugin injects into the templates. Finally, due to unpredictable issues with blog posts and image deletions, I had to delete and recreate my test blog, which wiped everything.

I’m fairly certain that when I’m ready to apply my custom theme to my production blog, everything will break. Luckily, we can easily revert to another theme and perform a full rebuild. It’s tedious but seems like a reliable process.

Fri, 27 Mar 2026 18:03:43 -0400

Spent some time building my custom theme for Micro.blog with Claude Code. It works but the nature of Hugo processing with different templates complicates the process. What works on the main timeline won’t always work on individual posts. Lot’s of back and forth to test and fix things. The good thing is that I’m building exactly what I want.

You can see the current design right here.

Thu, 26 Mar 2026 21:46:15 -0400

Another milestone accomplished: I now have a basic custom theme installed on my Micro.blog test website. It’s not a plugin per se; it’s a custom theme stored on my GitHub account that Micro.blog fetches. I don’t yet know how to turn it into a plugin with version numbering and all that, but I might not need that after all. I just wish Micro.blog would update automatically whenever I push a new change to my repo, like Vercel does.

Wed, 25 Mar 2026 20:45:13 -0400

I recently decided to drop the numericcitizen.io domain name and focus on numericcitizen.me for all my needs. The former was tied to a Craft subscription that I’ll cancel, too. I prefer to manage everything inside a single space under a single domain. It’s cheaper.

Tue, 24 Mar 2026 22:01:13 -0400

Continuing my thinking about a custom-built Micro.blog theme plugin, I wondered why most of Micro.blog themes design card-based? Here’s Claude AI’s answer:

Cards became the dominant Micro.blog theme style largely by following a broader web design trend from the mid-2010s, when Pinterest and Material Design made cards ubiquitous. Theme authors adopted them because they handle variable-length content safely and look great in screenshots. The fork-from-fork nature of many Micro.blog themes then perpetuated the pattern. The irony is that cards aren’t actually the best fit for Micro.blog’s typical stream of short title-less posts — making it a real opportunity for anyone wanting a distinctive, better-suited design.

Besides the fact that Micro.blog launched in 2018, the rest of Claude’s response makes me think that my design choice of a left sidebar, similar to Micro, is a good one.

Vibe Coding a Custom-Built Micro.blog Theme Plugin

Mon, 23 Mar 2026 12:34:00 -0400

I started working a my next vibe coding project: building my own Micro.blog theme plugin. I wanted to have one even before vibe coding was a thing, but I didn’t have the experience with Hugo and Micro.blog theme creation. With Claude Code, having that knowledge is secondary to the task, but having a clear mind about the desired final product is paramount. I started gathering specifications that will end up in some form in the specs.md file that I’ll feed to Claude Code. I’m also gathering design tidbits that reflect what I like. Ultimately, all my Micro.blog sites will share most of the design elements. Thanks the goal.

I plan to provide more updates about this little project, here on my meta blog. I’m doing all my work in Craft, a great tool for such project. I might decide to share my document with you dear readers if you show sign of curiosity.

My Micro.blog Timeline Summarization Workflow

Wed, 14 Jan 2026 07:43:12 -0400

By popular request, here’s the documentation for my n8n workflow. This documentation was created with Claude AI using Claude Skills and was slightly tweaked to remove any sensitive data. The diagram was manually added.

What Happened in Recent Days - A LOT

Sun, 04 Jan 2026 22:33:48 -0400

Over the past few weeks, I’ve been on an intensive learning journey exploring automation, cloud deployment, and AI integration. I’ve been hands-on, building real workflows and connecting actual services. Here’s what I discovered along the way.

Getting Started with Automation

The foundation of this exploration was deploying n8n as a self-hosted instance on a cloud provider. This wasn’t just about clicking a button—it required understanding infrastructure, configuration, and the basics of running a service in the cloud. Once that was in place, I could start building workflows.

Building basic workflows in n8n taught me what it actually means to create a functional automation. It’s not enough to have a good idea; you need to understand how data flows through your workflow, how triggers initiate actions, how conditions branch logic, and how errors are handled. Meeting all the requirements for a working workflow meant learning to think systematically about each step and its dependencies.

Accelerating Learning with AI

One of the biggest breakthroughs was leveraging Claude AI to accelerate my learning across different subject matters. Rather than struggling through documentation alone or spending hours debugging, I could ask targeted questions and get explanations tailored to my specific use cases. This fundamentally changed how quickly I could iterate and experiment.

Claude became my learning partner—helping me understand concepts, troubleshoot issues, and even write code. This wasn’t just about saving time; it was about compressing what might have taken weeks of traditional learning into days of focused experimentation.

Building and Connecting

From there, I expanded into multiple directions simultaneously. I deployed Next.js apps on Vercel using Claude Code, which gave me a way to build custom web interfaces quickly. I integrated GitHub for continuous delivery, automating the process of pushing code changes to live services like Scribbles and Micro.blog.

But the real power came from connecting external services directly into n8n workflows. I learned to interact with Telegram, Discord, Micro.blog, and Tinylytics through their APIs, webhooks, and HTTP requests. Each integration taught me something different about how modern services communicate with each other. Some services have well-documented APIs; others require reverse-engineering their webhook payloads. Some are straightforward; others have quirks you only discover through experimentation.

The Deeper Challenges

The more complex problems emerged when I tackled data persistence and LLM integration within n8n. Adding state management to automation workflows isn’t trivial—you need to decide where to store data, how to retrieve it, and how to keep it synchronized across multiple workflow runs. It’s one thing to run a workflow once; it’s another to run it reliably over time while maintaining context and history.

Incorporating AI services—whether through pay-per-use models like Claude or subscription-based services—required careful consideration. I had to think about cost implications, rate limits, and how to structure requests efficiently. Suddenly, every API call had a price tag, and I became much more conscious of resource consumption.

Key Insights

What stands out most is a clearer understanding of tool selection. Each platform has its place, and knowing when to use n8n versus a custom Next.js app versus a direct API call makes all the difference. Sometimes the right answer is a simple webhook; sometimes you need the flexibility of a full application. This contextual thinking has become invaluable.

I’ve also learned to transpose ideas into concrete use cases, leveraging service APIs from Scribbles, Tinylytics, and Micro.blog in ways I hadn’t considered before. What started as “I wonder if I can connect these services” became “Here’s a specific workflow that solves a real problem.”

I’ve discovered how to make the most of services I was already depending on—Micro.blog and Inoreader—by understanding their capabilities more deeply. These tools had features and integrations I’d overlooked, and now I’m using them in ways that actually enhance my workflow.

I’ve also expanded my toolkit with utilities like VS Code, GitHub, and Postman, each playing a crucial role in different parts of the workflow. VS Code became my development environment, GitHub my version control and deployment trigger, and Postman my tool for testing and understanding APIs before integrating them into n8n.

The Bigger Picture

The journey has been about understanding not just individual tools, but how they fit together in a larger ecosystem. It’s about recognizing that modern development isn’t about mastering one tool—it’s about understanding how to orchestrate multiple tools to solve real problems. And it’s about using AI not as a replacement for learning, but as an accelerant that lets you learn faster and go deeper.

Building an Automated Publishing Pipeline: From Craft to Ghost

Fri, 02 Jan 2026 17:57:27 -0400

For months, I’ve been publishing my weekly newsletter, The Ephemeral Scrapbook, using a manual process: write in Craft, export to Ulysses, copy to Ghost, reformat everything, add images, fix formatting issues, and finally publish. It worked, but it was tedious and time-consuming.

Today, that process is fully automated. Here’s how Claude and I built it together.

The Challenge

My workflow had become a bottleneck:

Writing newsletters in Craft Docs (my preferred writing environment)
Exporting to Ulysses as an intermediary step
Manual copy/paste to Ghost (my publishing platform)
Reformatting all the markdown and HTML
Dealing with Craft-specific formatting that Ghost didn’t understand
Adding metadata like excerpts and tags manually

I wanted automation, but I also wanted to understand the infrastructure I was building. That’s where working with Claude became invaluable—not just executing commands, but learning and iterating together.

The Solution: n8n Workflow Automation

We decided to build an n8n workflow that would:

Search for a document in Craft by title
Fetch all the content blocks
Transform Craft’s markdown/blocks into clean HTML
Publish to Ghost as a draft
Return confirmation with the post URL

Simple in concept, complex in execution.

The Journey: Key Milestones

Milestone 1: Understanding the Architecture

Challenge: Should we use multiple workflows or one unified workflow?

Decision: One end-to-end workflow that handles everything from search to publish.

Learning: Simplicity wins. Rather than orchestrating multiple workflows, we built one cohesive pipeline that’s easier to debug and maintain.

Workflow nodes:

Webhook (trigger)
HTTP Request (search Craft)
HTTP Request (fetch document)
Code (transform to HTML)
HTTP Request (publish to Ghost)
Respond to Webhook

The Iterative Building Process

One of the most important decisions we made was to build and test incrementally. Rather than assembling the entire workflow at once and hoping it would work, we added one node at a time, testing after each addition.

The Testing Cadence:

Add Webhook → Test: Confirmed the webhook received the query parameter correctly
Add Search Node → Test: Verified we could find the document and get the correct document ID
Add Fetch Node → Test: Checked that we retrieved all 54 blocks of content with the proper nested structure
Add Code Node → Test: Validated the HTML transformation, checking for clean output without Craft tags
Add Ghost Publish Node → Test: Ensured the post was created as a draft with all content intact
Add Response Node → Test: Confirmed the workflow returned post details back to Claude

Why This Mattered:

Each test revealed issues that would have been much harder to debug in a complete workflow:

The search node helped us understand Craft returns multiple matches (we needed the first result)
The fetch node showed us the nested structure (parent document → edition page → content blocks)
The code node iterations caught formatting issues (<callout> tags, ## symbols, <highlight> tags)
The Ghost publish node revealed we needed the ?source=html query parameter

By testing at each step, we could pinpoint exactly where problems occurred. When something didn’t work, we knew it was the node we just added, not some mysterious interaction between distant parts of the workflow.

This incremental approach turned what could have been hours of debugging into a smooth building process. Each successful test gave us confidence to move forward, and each failure was easy to isolate and fix.

Milestone 2: Building the HTML Transformer

Challenge: Craft uses its own markdown dialect with special tags like <callout>, <highlight color="blue">, and markdown headers in text blocks.

What we built: A comprehensive JavaScript transformation engine that:

Removes Craft-specific tags (<callout>, <highlight>)
Converts markdown formatting (bold, italic, links, code)
Processes different block types (text, headers, quotes, code, images, videos)
Handles rich URL blocks (YouTube embeds)
Preserves anchor links for internal navigation
Generates proper HTML for Ghost’s Lexical editor

Key functions:

markdownToHtml() - Converts inline markdown to HTML
processBlock() - Handles each block type (text, image, richUrl, code, line, etc.)

Milestone 3: Testing and Validation

The Process:

Test with real content (Edition 2025-52 with 54 blocks)
Verify HTML output in Ghost’s editor
Check for Craft formatting artifacts
Confirm all sections, videos, quotes, and images are preserved

Quality Checks:

✅ No <callout> tags
✅ No <highlight> tags
✅ No ## symbols in headers
✅ All YouTube videos embedded correctly
✅ Blockquotes formatted properly
✅ Images included
✅ 9-minute reading time (17,000+ characters)

The Final Workflow

Input: {"query": "The Ephemeral Scrapbook — Edition 2025-52"}

Output: Draft post in Ghost with:

Complete HTML content
All formatting preserved
Clean structure
Ready for manual review (add images, tags, excerpt)

Execution time: ~3-4 seconds total

Search: 1-2 seconds
Fetch: 1-2 seconds
Transform: 36-84ms
Publish: 600-900ms

The Tools

Craft: My writing environment with a powerful API
Ghost: My publishing platform with a robust Admin API
n8n: Workflow automation platform (self-hosted on DigitalOcean)
Claude AI: My pair-programming partner via MCP (Model Context Protocol)

The Result

The workflow is production-ready. My publishing workflow went from 20+ minutes of manual work through Craft, Ulysses, and Ghost to a single command:

“Claude, publish Edition 2026-01 to Ghost”

And it just works. 🎉

Mon, 29 Dec 2025 17:38:22 -0400

Here’s a quick demonstration of the Microblog Poster web app I mentioned in my previous blog post.

Why I Built a Micro.blog Front End?

Sun, 28 Dec 2025 22:36:28 -0400

As recently shared on my blog, I have finished (or mostly finished¹) building a simple front end for Micro.blog. This front end, as depicted in the following screenshot, presents the user with a straightforward UI: a title field, a body field, blog post categories, and a Publish button—very focused, with no distractions. It works on desktops and mobile devices. I even added PWA support. But why did I build this?

First, I wanted to dip my toes into Vercel. I’ve recently stumbled upon many posts about web apps built and deployed on Vercel by people claiming no programming experience. Most people were using Claude AI or Claude Code to describe their app and deploy it to Vercel. Some apps were impressively designed and functional. Yet, I thought it wasn’t that easy and required a lot of technical knowledge. I was intrigued. I was “mostly” wrong.

I’ve been using Claude AI since mid-December, in conversational mode, for different tasks, including getting explanations on building apps on Vercel and other platforms. I’ve been looking for small project ideas since then. Building a simple front-end to Micro.blog quickly became the perfect test. Micro.blog offers a simple API for many things. Using Claude and the API documentation, I asked Claude AI whether it was possible to build a simple UI for posting on Micro.blog. Sure enough, it was. My initial prompt describing the envisioned app follows:

Let’s build a web app hosted on Vercel that lets me to write blog posts for Micro.blog. The form will include only two text fields: a blog post title and the blog post text itself. Include a character count that will update as I type. Maximum of 5000 characters. The web page should include a title “Microblog Poster", centered.

Micro.blog supports Markdown, so the blog post text field should support it too.

The authorization token should be stored in an environment variable named “microblog_token” which I will provide once the project is created on Vercel.

I will use a GitHub repo, which should be named after the application name: “(redacted)” where the app will use the full URL: https://(redacted)

Provided that Micro.blog supports draft posts as exposed in the Micro.blog APIs, a toggle named “Draft” should be on the web form and be off by default. When enabled, this means I can send the blog post to Micro.blog but with a draft status. Otherwise, the blog post is published.

The initial state of the web app is to list all available blog post categories as a series of checkboxes, all off by default. You will need to retrieve possible blog post categories during the initialization phase. A blog post can have more than one category selected or none. This list of checkboxes should be left-aligned. The category list should be saved in the browser’s local storage and initialized on the first invocation of the web app.

The form will contain a button “Publish” centered horizontally (like all the other UI elements, except the toggle underneath the Publish button which should be left aligned. Once clicked, if the post operation is successful, add a small banner (centered) telling me the operation was successful with an appropriate message.

For a non-draft post, after hitting Publish, the form should display a clickable link to the blog post’s final URL. For the draft post, you should display the clickable link to the draft post instead.

Images or any other attachments are not needed.

You can look at micro.blog API documentation in the following URLs:

For reading data from Micro.blog service: https://help.micro.blog/t/json-api/97

For posting to Micro.blog service: https://help.micro.blog/2017/api-posting/

After a few hiccups and errors, it eventually worked. I had to install GitHub Desktop on My Mac as well as Visual Source Code, but I eventually realized Claude AI wasn’t optimal. I ultimately switched to Claude Code to iterate on the initial release. My experience was so much smoother. I do experience so weird issues with GitHub, but it seems without impacts on the deployment.

So, building the app requires a GitHub repository for holding the source code. Vercel connects to my GitHub repo, and as soon as a new commit is made, a new app deployment happens; It’s all automatic. One important thing to know: a project environment variable² to hold the Micro.blog app token is needed before trying the app for the first time.

My first try mainly worked as expected. I made sure to have a draft mode available in the UI so that I don’t mess up my timeline with test posts. Once the app is deployed and available for use, any modifications are made through prompting Claude Code on my local machine. Code changes are pushed to GitHub on demand. It takes a few minutes for a new iteration to be available for testing.

If you have any questions or comments, feel free to post them, and I’ll do my best to answer them to the best of my knowledge.

One more thing: Vercel is free to use in my case because my app is relatively lightweight. Lastly, one benefit of building my app is that it will circumvent a design issue with Micro.blog’s post editor on the web: the title field and categories aren’t listed by default. I find this to be annoying. My app shows them. I’m happy with that.

Software is never finished! ↩︎
It’s the most secure way to keep that token away from unauthorized eyes. ↩︎

Fri, 19 Dec 2025 21:30:10 -0400

Enabled the RSS feed in the News section of “Who is Numeric Citizen” website.