I Built a Notion Publishing System Without Looking at the Code

Mathias Biilmann

I’ve been a programmer for decades now, and originally learned to build software on a Commodore 64 back in the late 80’s. Right now I feel I’m in a process of relearning software development in a world where “code” is just not that important.

A few weeks ago, I decided to solve a problem that had been nagging me for months: getting my Notion documents published to my blog required tedious manual work. Copy-paste, reformat, fix images, add front-matter, create pull requests. All of this should be done by an AI, not by me!

But here’s what made this project different: I built an entire production system without ever looking at the code.

screenshot of my publishing system

This is a fundamentally new way of working on software, where I would carefully describe the overall approach and results I wanted, while Claude Code handled all the implementation details and I focused on the architecture, the innovation, the user experience and the outcomes.

Going From Unstructured to Structured

In the land of front-end frameworks, templates and code, we need structured data as our building blocks, we can’t do with free form text documents. Biilmann Blog is built with the site generator Astro, and each article is stored as a markdown document with front-matter.

However, when I work on my articles, I typically work in Notion and get comments and feedback from my team in there. Notion docs are somewhat structured as well, but it’s not a 1-1 mapping to markdown. Things like title, description, and summary for the home page listing are not directly present in the Notion doc. And until now, it required me (or some other human) to manually turn the Notion doc into a proper blog post.

The workflow I built allows AI to transform unstructured content into structured data seamlessly. Here’s what happens when I publish an article now:

  1. I search my Notion workspace and select a document.
  2. OpenAI processes the raw Notion blocks from the API and extracts clean metadata.
  3. The AI acts as a copy editor, creating proper frontmatter, title, description, choosing header types, setting up code blocks, and fixing outright typos or grammar errors.
  4. Images get downloaded from Notion’s private S3 bucket, stored in Netlify Blobs and served through an Edge function on the edge.
  5. A GitHub pull request appears with the finished markdown file.

The transformation from Notion’s rich block structure to clean markdown with proper metadata happens entirely through AI. No manual tagging, no formatting cleanup, no image wrangling, but an intelligent conversion that understands the difference between content and structure.

Coding without Code

What fascinated me throughout this project was how I could work at the intention level rather than the implementation level. For the first outline of the functionality, I was use fairly detailed prompts specifying to Claude how to approach this and what primitives to use, but once the rough functionality was in place I found myself telling Claude Code things like:

I want users to be able to search their Notion documents and see results as they type

When processing takes more than a few seconds, show a progress bar with what's happening

If someone tries to publish the same Notion document twice, update the existing article instead of creating a duplicate

Claude Code would respond not just with code, but with complete working systems. It understood that a search interface needed debouncing, that long-running processes needed background functions, that duplicate detection required GitHub’s API integration. I never had to think about HTTP status codes, database schemas, or error handling patterns.

The Primitives: Netlify’s Serverless Stack

What I did do initially was make the proper architectural decisions, I guided Claude Code toward Netlify’s serverless primitives:

  • Background Functions for the 15-minute AI processing pipeline
  • Blob Storage for drafts, status tracking, and image management
  • Edge Functions to serve processed images from Blob Storage with proper caching
  • Functions for the API layer connecting Notion, OpenAI, and GitHub

The beauty was that I could say “use Netlify Background Functions for this long-running process” and Claude Code would implement the entire queuing system, status polling, error recovery, and progress tracking. I specified the what and which tool, but only rough guidelines on the how.

Three APIs, Zero Integration Headaches

Building this system required orchestrating three complex APIs:

Notion API - For searching documents and retrieving block-structured content OpenAI API - For intelligent content transformation and metadata extraction GitHub API - For branch management, file creation, and pull request workflows

Traditionally, integrating three APIs like this would involve a lot of non-creative work: reading documentation, handling edge cases, managing rate limits, and debugging authentication flows. With Claude Code, I described what I wanted the integrations to accomplish, and it just worked.

The GitHub integration particularly impressed me. It handles OAuth flows, creates feature branches, detects duplicate articles by Notion ID, and generates structured pull request descriptions—all from high-level direction about wanting a “review workflow for published content.”

AI as my Copy Editor

The most sophisticated part of the system is how OpenAI transforms unstructured Notion content into structured blog posts. I guided Claude Code to design a prompt that acts as a copy editor rather than a content rewriter:

The AI analyzes Notion’s nested block structure, extracts proper metadata (title, description, publish date), converts formatting to markdown, and handles rich media — all while preserving my writing style and technical accuracy.

The result is clean markdown with proper front-matter ready for immediate publication. The transformation from Notion’s flexible document format to blog-ready markdown happens seamlessly through AI’s understanding of content semantics.

The finished system handles everything I wanted, and more importantly, it actually works in production. I’m using it to publish real articles to my blog. The error handling is robust, the user experience is good enough, and the AI content transformation preserves the quality I care about.

Relearning Software Development

Initially, when I started trying to write code with LLMs, I mostly felt frustrated. I felt like the core discipline of carefully building up a mental image in your head of a complex, abstract structure — and making exactly the right decisions to evolve that structure — was being replaced by constantly begging a probabilistic engine to do the right thing.

Now I’m starting to feel like this is some of the most fun I’ve ever had writing software, and starting to realize that my core skills — creativity, architectural knowledge, systems design, user experience design and an overall sense of what’s possible— are more powerful than ever. The time consuming work of writing glue code for a bunch of libraries, wrestling with UI widgets, reading through docs or studying codebases, is something I can now fully delegate.

Building software without writing code demands as much skill as building software by typing every line by hand. After all, even when doing traditional software development, the actual time spent typing is minuscule compared to the rest of the work. It’s not a magic bullet where 1 prompt gets you a working system; context engineering and thoughtful system design are keys to unlocking this new discipline.

What’s clear, however, is that we’re at a turning point: models are getting so strong at writing code, that as developers, we must relearn how to build in a world where code is no longer terribly important or valuable and where our level of abstraction has moved one layer up.

The Meta Moment

There’s something beautifully recursive about this whole project. I wrote this article in Notion, then used the very system I built to publish it to my blog. The AI processed the unstructured content, extracted the metadata, handled the images, and created the GitHub pull request — all without me touching a single line of code.

It’s a working demonstration of the new paradigm: focus on outcomes, let AI handle implementation, and build exactly what you need rather than settling for existing tools.

The tools we build today will shape how we work tomorrow. When the barrier between intention and implementation disappears, everyone can become a builder.

This article was written in Notion and published using the AI-powered system described above. The outline of the article was written by Claude Code by prompting it to write about the process.