Blogdel

• 

  Blogdel Homepage

Inspiration

Blogdel was inspired by the possibility of artificial intelligence interacting with the real world without requiring constant human intervention.

After building several projects with AI, I noticed that most AI products still behave like chatbots: they wait for a prompt, produce a response, and then return to a dormant state. Even when the underlying model is capable, the surrounding product often reduces it to a text box.

That led to a different question:

What would happen if AI were given a complete system to operate rather than a conversation to answer?

Blogdel explores that idea through publishing. Instead of placing an AI model inside a local experiment or a tightly isolated demo, I wanted to give it a public platform with real responsibilities. It needed to discover ideas, create assignments, generate articles, validate its output, store information, update state, recover from provider failures, and publish work that real people could visit and read.

The goal was not simply to make AI write blog posts. It was to build a small editorial organisation that AI could operate.

What it does

Blogdel is an autonomous editorial platform with both a public publication and a private operations dashboard.

The system follows a complete source-to-publication workflow:

Sources
   ↓
Source items
   ↓
Delegation jobs
   ↓
AI generation
   ↓
Schema and reference validation
   ↓
Database storage
   ↓
Publication

Blogdel can:

• collect and organise editorial ideas;
• create traceable writing assignments;
• assign articles to persistent AI author identities;
• generate structured articles through an ordered provider chain;
• validate every article before it enters the publication;
• enforce category-specific reference requirements;
• record provider attempts, failures, and fallbacks;
• store articles, jobs, authors, references, and system history;
• publish content automatically through scheduled production runs;
• provide administrators, editors, and reviewers with different access levels.

The public site covers ten categories:

• Technology
• Health
• Sports
• Politics
• Entertainment
• Business
• Science
• Education
• Food
• History

Behind the public interface is a digital newsroom where the full editorial process remains visible.

How we built it

Blogdel was built as a collaboration between human direction and specialised AI systems.

GPT-5.6 Sol

GPT-5.6 Sol was used to:

• plan the overall architecture;
• define the editorial workflow;
• review implementations across the codebase;
• identify bugs, security weaknesses, and production risks;
• diagnose provider failures and guide technical decisions.

Codex

Codex was used to:

• write and refine the application code;
• build the public publication and administrative newsroom;
• debug authentication, generation, and scheduling failures;
• secure the production cron endpoint;
• maintain the repository and push production changes.

Casey Tembo

I was responsible for:

• conceiving the original product;
• defining its purpose and constraints;
• establishing the foundational structures;
• directing the design and technical priorities;
• testing, orchestrating, and making the final production decisions.

The application was built with:

• TypeScript
• TanStack Start
• React
• Vite
• Tailwind CSS
• shadcn/ui
• Supabase PostgreSQL
• Zod
• Lovable Cloud
• Groq, Gemini, Cerebras, and Lovable AI

Groq is the primary article-generation provider. Gemini, Cerebras, and Lovable AI form the ordered fallback chain.

Every generation attempt is recorded. Failed providers remain visible, and completed articles must pass strict structural and reference validation before they can be stored or published.

Challenges we ran into

One of the biggest challenges was moving from a working AI demo to a reliable production pipeline.

The first version could generate articles, but generation alone was not enough. The system also needed to explain which provider was used, why a fallback occurred, whether the response contained valid JSON, whether it satisfied the Zod schema, and whether it met the reference requirements for its category.

At one point, Groq silently failed and the system fell back to Lovable AI. The article still appeared, but the reason for the fallback was not visible. We rebuilt the provider-event logging so Blogdel could distinguish between:

• missing API keys;
• authentication failures;
• rate limits;
• timeouts;
• provider server errors;
• invalid JSON;
• schema failures;
• network errors.

Another challenge was production scheduling. Blogdel needed to wake itself up without exposing its cron token. The final system uses PostgreSQL scheduling, pg_cron, pg_net, and Supabase Vault so authenticated production requests can run three times per day without embedding secrets in the repository.

We also had to balance autonomy with control. The public platform needed to operate independently, while the admin dashboard still had to preserve human visibility, reviewer access, and clear system boundaries.

Accomplishments that we're proud of

The most important accomplishment is that Blogdel is not a simulated workflow.

The complete production pipeline has been tested:

Scheduled trigger
   ↓
Authenticated request
   ↓
Source processing
   ↓
Delegation
   ↓
AI generation
   ↓
Validation
   ↓
Database storage
   ↓
Public publication

A live autonomous test processed four source items, completed four delegation jobs, and published four non-demo articles without manual generation.

Other accomplishments include:

• a live public domain at blogdel.blog;
• a complete database-backed editorial system;
• an authenticated operations dashboard;
• role-based admin, editor, and read-only reviewer access;
• strict article schemas and reference requirements;
• observable provider fallbacks;
• manual and batch generation;
• scheduled publishing three times per day;
• responsive article and category pages;
• a public repository containing the complete implementation.

Most AI publishing tools stop when the model returns prose. Blogdel treats that response as the middle of the process, not the end.

What we learned

The main lesson was that autonomy does not come from the intelligence of a model alone.

A model can write an article, but a working autonomous system also needs:

• persistent state;
• scheduling;
• permissions;
• validation;
• observability;
• fallback behaviour;
• error recovery;
• clear operational boundaries.

We also learned that AI collaboration works best when different systems are given distinct responsibilities.

GPT-5.6 Sol was strongest as a planner, reviewer, and technical coordinator. Codex was strongest as a repository-level developer and debugger. The generation providers were strongest as specialised writers operating inside the system. My role was to define the objective, direct the process, and decide what was acceptable for production.

The result was not one AI doing everything. It was an organised team of tools operating under one product vision.

What's next for Blogdel

The Build Week version proves that Blogdel can operate as a complete autonomous publication.

The next stage is to turn that proof into a stronger real-world editorial platform by adding:

• more live and trusted source integrations;
• improved editorial ranking and topic selection;
• stronger duplicate-story detection;
• richer author identities and specialisations;
• automatic image sourcing;
• deeper article revision and fact-checking stages;
• clearer public explanations of AI involvement;
• improved analytics and editorial performance tracking;
• stronger production security and secret rotation;
• expanded human review controls where required.

The long-term goal is not to remove people from publishing.

It is to explore what becomes possible when AI is given responsibility, structure, memory, and accountability instead of another empty prompt box.

Built With

• chatgpt
• codex
• lovable
• webdeveloper