For the past few years, I’ve been experimenting with how software gets built when you have coding agents doing the heavy lifting.

Subscribe now

I come from a developer background, and like most people who build software products for a living, I’ve watched the tooling change fast. What started as autocomplete and code suggestions has become something much more capable: agents that can reason through a task, scaffold features, refactor large sections of a codebase, debug issues, and even help ship full-stack apps with surprising speed.

Over the last three years of what people now call vibe coding, I’ve tried a bunch of tools and workflows. Most of them fall into three buckets:

1. IDEs (Integrated Development Environments)

2. Coding agents inside the CLI

3. Desktop apps

Of course, all of these tools have their own pros and cons.

IDE vs CLI vs desktop app

IDEs like Antigravity, Cursor, or Kiro are all forks of VS Code. They offer a familiar environment for developers and an easy-to-use UI for beginners.

But the tradeoff is speed.

Because of all the UI components loaded at once, latency can become noticeable. Speed matters a lot to me, so when IDEs lag or crash, I get really frustrated.

Another thing is having to switch between the prompt field and the terminal. I find that part a bit cumbersome, and I often get confused between the two.

Then there is the terminal.

Hardcore devs will always prefer using the terminal. You can run commands quickly, and you don’t suffer as much from latency. It’s fast, flexible, and feels natural once you’re used to it.

Before Warp, I was running Claude Code in a plain CLI on Mac. Fast, flexible, and useful to me as a developer.

But a few things kept bugging me:

• If I wanted to check the source code, I’d have to open a separate IDE to look at what changed.

• Organizing multiple instances of coding agents across multiple open terminals was messy without tabs.

• There were no notifications when an agent was thinking, out of tokens, or done working.

As the project gets bigger, code review, task monitoring, and managing multiple agents get painful.

The desktop app is the option I enjoy least. OpenAI’s Codex and Anthropic’s Claude desktop app are two of the most popular right now.

Too simple and too slow for how I work. For beginners, it’s probably fine because you don’t have to deal with technical stuff like commands. All you really need to worry about is writing a good prompt and letting the AI handle most of the work.

But here’s the thing: you don’t have to pick between these environments.

There’s another agentic coding tool called Warp that gives me the speed and lightness of the CLI and the ease of use of a more visual tool.

Let me walk through how I use Claude Code with it.

Why I switched to Warp

Warp is an agentic development environment, born out of the terminal. I tried it about a year ago and liked it immediately.

What hooked me right away was that it didn’t feel like a bloated IDE, but it also didn’t feel like a bare terminal that leaves you to figure everything out on your own. It sits somewhere in the middle, and that’s exactly where I want to be when I’m working with coding agents.

It’s lightweight. It’s fast. It supports multiple models. It feels agentic. And it gives me something between a terminal and a full IDE without making me commit to either one.

It didn’t replace the parts I liked about using Claude Code in the terminal. It just made the experience around it better.

Get 20% off for 1 year

How I use Claude Code in Warp

In the prompt field, Warp accepts terminal commands, so when you type “/model,” it’ll show all supported models. Open the “Full Terminal Use” tab, and you can see every Claude model available to you.

You can also choose other models or launch Warp’s Oz orchestrator to handle the agent scaffolding for you.

Now, whenever I prefer to work inside Claude Code instead of Warp’s built-in composer, I can simply run “claude” and continue using it as I would inside the CLI.

This is pretty cool, right? To switch back to the composer, I just click on the “Compose” button.

CLI Agent Toolbar

Another reason I prefer Warp over a default CLI terminal is the customizable controls in the toolbar section.

Power users want their agent workflow tailored to them. The toolbar puts the right controls at your fingertips without leaving the terminal.

To get to it, right-click on the toolbar section and select “Edit CLI agent toolbelt.”

This brings up a modal where you can customize which tools appear on both the left and right sides of the toolbelt.

Here’s my default setup: no voice input since I prefer typing my prompts, no session sharing since I’m a solo dev, and I always want to see which branch is active on which project folder.

If you work on a team, it’s worth enabling the current logged in user and the shortcut to share your session with other team members.

I stay in one environment with quick access to the things I actually need when working with an agent. No bouncing between different apps just to give better context or review what changed.

That is a big part of why Warp feels more complete than a plain terminal.

Unified Notifications

Agents run in the background, and they do not always need your attention right away.

• Sometimes they are still thinking.

• Sometimes they are waiting for a response. S

• Sometimes they are out of tokens.

• Sometimes they are done and ready for the next instruction.

In a regular terminal, you kind of have to babysit all of that yourself.

Warp fixes this with a unified notifications UI that keeps you in sync with all your agents across tabs. You do not have to keep checking every session manually just to see whether something happened. Desktop notifications are also supported, which is especially useful when you are multitasking.

Click on the “Enable Claude Code notifications,” and this will install the Claud Code plugin.

On bigger projects with longer-running tasks, I rely on notifications constantly. I used to alt-tab through terminal windows just to check whether an agent was stuck or waiting on me. That got old fast. Now I don’t have to.

Code Review Comments

Agents can write code fast. But humans are still the ones responsible for making sure the code is actually good.

That’s why I like Warp’s code review comments feature.

Instead of treating code review as something completely separate from the agent workflow, Warp keeps the loop tight. I can review agent-generated code, leave inline comments, and send that feedback directly to a running third-party agent session.

Here’s an example:

That means the agent can iterate based on very specific feedback without me having to manually re-explain everything in another window.

This is a really smart workflow improvement.

One of the biggest gaps in agentic development right now is that generation is easy, but iteration can still feel clunky. Warp makes that feel much smoother. You can generate, review, comment, and course-correct all in one place.

Get 20% off for 1 year

Why this setup matters

If you’re already using coding agents or thinking seriously about building with them more often, this kind of setup matters for a few reasons.

The first reason is speed.

And I do not just mean model speed. I mean your actual working speed as a developer. How quickly can you launch the right setup, hand over context, review changes, monitor progress, and move across tasks without breaking focus? That’s where the environment around the agent makes a difference. A plain terminal doesn’t help you much there. An IDE might, but you pay for it in weight and latency.

The second reason is visibility.

Once you start using agents more heavily, you need better awareness of what each session is doing. You want an easy way to know when an agent needs attention, when it’s done, or when you’re about to hit a token limit. That’s much easier when your environment is actually designed for it, rather than something you’re duct-taping together across multiple windows.

The third reason is flexibility.

You’re not limited to one model. You can switch between them depending on what you need. Sometimes you want something faster. Sometimes you want stronger reasoning. Sometimes you want to save money. Being able to pick the right model for the right task is one of the easiest ways to work more efficiently and keep costs under control.

The fourth reason is that Warp seems to listen to developers.

This matters a lot in a space that’s changing as quickly as agentic development. The tools that win here are the ones that move fast, pay attention to how developers actually work, and keep shipping useful stuff. From what I’ve seen, Warp has been more consistent about that than most of the competition.

I encourage you to follow their X account to see how much they listen and how quickly they make sure all major concerns are addressed.

And from personal experience: it’s been useful. I’ve been building my apps with Warp, and my Claude Code workflow is noticeably better for it. Not because it changes what Claude can do on its own, but because it makes everything around Claude smoother.

Final thoughts

To summarize everything, my ultimate Claude Code setup is really about combining the strengths of different environments without being forced to fully commit to only one.

I talked about the tradeoffs between IDEs, the CLI, and desktop apps. IDEs are familiar and approachable, but they can feel heavy. The CLI is fast and flexible, but it gets messy as projects and agent sessions grow. Desktop apps are simple, but for me, they often feel too limited for serious work.

That is why Warp works so well in this setup.

It gives me the speed and lightness I want from the terminal, while also giving me a better experience around code review, task monitoring, multiple agent sessions, and prompt composition. Features like Vertical Tabs, notifications, the CLI agent toolbar, Code Review Comments, and model flexibility all add up to a workflow that feels much more practical for real agentic development.

Personally, using Claude Code with Warp has made me more productive, more organized, and a lot more comfortable working across larger projects. It helps me stay in flow, manage more agents at once, and spend less time dealing with the awkward parts of the workflow.

Of course, this is still based on my own personal preferences. Everyone has a different way of working, and that is completely fine. The good thing is that Warp gives you enough flexibility to explore the app and customize the setup however you want.

If you are already using Claude Code, I think Warp is worth trying.

Give Claude Code in Warp a shot, test a setup that fits your workflow, and let me know what you think about the experience.

Hi there! Thanks for making it to the end of this post! If you enjoyed this content and would like to support my work, consider becoming a paid subscriber. Your support means a lot!

Support my work

Hey guys, it has been a week since I launched BloggFast.

For those who are new here, BloggFast is a Next.js blog boilerplate that gives you a fully wired, production-ready AI-powered blog site out of the box. Instead of spending weeks integrating authentication, database, CMS, email, hosting, and AI services, you get all of that configured and connected on day one.

Subscribe now

So, if you are still paying for platforms like Webflow, Framer, or WordPress, you can finally ditch them and use BloggFast instead.

You do not need to keep paying a monthly subscription just because you reached a certain limit on content, pages, storage, or traffic. You have full control over your content. You own the source code. You can modify it, extend it, self-host it, or turn it into something completely different.

It is also very easy to set up.

In this post, I want to share five of the latest features and improvements I shipped this week. Here is a quick summary:

1. New article scheduler

2. OpenClaw integration

3. New comment section on articles

4. New model support with Opus 4.7

5. Reduced pricing

Let me get into the details.

1. New article scheduler

BloggFast now has a new Calendar tab on the left menu.

From here, users can schedule posts by hovering over a calendar date and clicking the + button. This makes it much easier to plan content ahead of time instead of manually publishing every article the moment it is ready.

Users can also click Generate with AI, which redirects them to the AI article generator page. On that page, there is now a new Schedule button beside the publish button. This allows you to generate an article with AI and schedule it for a later date.

Going back to the calendar page, you can switch between three views.

1. The first one is the Calendar view, which gives you a clean monthly view of your scheduled articles.

2. The second one is the List view, which shows a full list of articles with their status and publishing date.

3. The third one is the Board view, which works like a Trello board. It organizes articles based on their status, so you can quickly see what is still in draft, what is scheduled, and what has already been published.

Here’s what the list view and the board view looks like:

Why add this?

I wanted to give writers the ability to prepare content ahead of time and put everything in a proper publishing queue. There are many cases where this becomes useful. For example, a new LLM might be teased for release, and you already want to prepare an article before the official launch. You can write it ahead of time, schedule it, and let BloggFast handle the publishing for you.

This is especially useful if you run a news-style blog or publish multiple articles per week. Instead of rushing every time you want to post something, you can plan your content calendar properly and keep your site active even when you are busy.

2. OpenClaw integration

This is the update I am most excited to share, but it is also the most technical one.

If you have not heard about OpenClaw yet, it is an open-source tool that lets you connect AI agents to real workflows. You can think of it as a bridge between your messaging apps, automation tools, and your own apps. Instead of opening your dashboard every time you want to perform an action, you can send a command through a bot and let the system do the work for you.

When I first released BloggFast, I wanted to give writers the ability to write and publish content to their own blog or news website through the built-in AI article generator.

However, there was still one blocker in the workflow.

To publish content, you still had to open your laptop, go to the BloggFast dashboard, write the content, review it, and publish it. It usually takes around 5 to 10 minutes for a 1,000-word article to go live.

That is already fast compared to the usual blogging workflow, but I wanted to improve it even more.

What if you could simply send a topic to a bot from WhatsApp, and then the bot asks BloggFast to write and publish the content for you?

That is the idea behind the OpenClaw integration.

Instead of manually opening the admin dashboard, you can send a topic from your phone. OpenClaw receives the request, sends it to BloggFast, and BloggFast generates the article for you. The article can then be prepared, saved, or published depending on your setup.

The turnaround time can go from around 10 minutes to about 1 minute.

Here is a simple visualization of the process:

On the left side menu of the admin panel, I also created a new menu called OpenClaw. This acts as the dashboard for all the requests sent by the bot and the articles created through OpenClaw.

Here’s a sample curl reference:

# Trigger generation
curl -X POST https://<your-domain>/api/openclaw/articles/trigger \
  -H “Content-Type: application/json” \
  -H “x-api-key: $BLOGG_FAST_OPENCLAW_API_KEY” \
  -d ‘{”topic”:”Your topic here”,”source”:”whatsapp”,”chatId”:”optional”}’

# Poll status  
curl https://<your-domain>/api/openclaw/articles/status/<jobId> \
  -H “x-api-key: $BLOGG_FAST_OPENCLAW_API_KEY”

# Cancel a job
curl -X POST https://<your-domain>/api/openclaw/articles/cancel/<jobId> \
  -H “x-api-key: $BLOGG_FAST_OPENCLAW_API_KEY”

For now, I will not go into the full setup process because it is a bit complicated. I will prepare a separate post that explains the step-by-step guide on how to set up your own OpenClaw workflow for free and connect it to BloggFast.

But honestly, this is one of the most exciting parts of the project for me.

It makes BloggFast feel less like a normal blog template and more like a real publishing system that can work with agents, bots, and automated workflows.

3. New comment section on articles

When you open an article, you will now see a new comment section at the end.

Guest visitors are allowed to view comments, but only logged-in users can leave a comment. The owner of the comment can also delete their own comments. Users can also upvote or downvote comments.

This makes the article page feel more alive. Instead of just publishing content and letting readers leave quietly, you can now start conversations around your posts.

I am also planning to allow anonymous comments in the future. Another feature I am considering is giving the author the option to turn off comments for specific posts.

That is still just a plan for now, so let me know what you think about it.

This new comment feature should have been part of the initial launch, but I had to delay it because I wanted to prioritize more important features first. But hey, it is finally here now.

You can now enjoy reading and commenting on other people’s posts directly inside BloggFast.

4. New model (Opus 4.7)

In case you missed it, Anthropic launched their latest and most capable model, Opus 4.7.

For BloggFast, this matters a lot because the AI article generator depends heavily on instruction following, long-form reasoning, research quality, and writing consistency. A better model does not just mean better text. It also means the system can follow your writing rules more carefully, understand article structure better, and produce content that needs less editing.

From my own testing, Opus 4.7 works very well for deep research, article writing, outlines, rewrites, and long-form content generation. It is especially useful when you want the AI to follow a specific tone, avoid certain words, or write in a format that matches your existing content style.

To switch the default model to Opus 4.7, open the Settings page. Under the AI Config tab, set the AI model to Claude 4.7 Opus Reasoning.

Save the settings and you are good to go.

How is the improvement?

Well, I noticed that Opus 4.7 is by far one of the best models to use for BloggFast. It follows instructions almost all the time, and it also uses the writing skills properly. Of course, you are free to try the other models, but this is the one I highly recommend right now for serious article writing.

Take note that the backend is wired to Vercel AI Gateway, so make sure that you have enough credits in your AI Gateway account.

And by the way, OpenAI just launched GPT-5.5, but the model’s API access is not publicly available yet. Once it becomes available, I will immediately add support for it inside BloggFast.

5. Reduced pricing

I received comments from writers saying that the pricing of BloggFast is a bit high.

So, I decided to offer a 75% discount to the first 50 customers.

I have poured a lot of sweat, time, and effort into this project. The amount of features and complexity inside BloggFast is not small. It is not just a UI template. It is a full-stack blog boilerplate with authentication, database, CMS, email, AI generation, article management, scheduling, comments, and now even automation support through OpenClaw.

The goal is to empower writers, publishers, indie hackers, and small teams who want real control and ownership over their platform.

So yes, I still believe the original pricing is justified. But I also understand that many writers and builders are careful with their budget, especially when starting something new.

That is why I decided to make the offer more accessible for the first batch of users.

What’s next?

I have worked on BloggFast for two months with the goal of giving writers and publishers more control and ownership over their platform.

I am committed to growing this product and continuously adding more features, improvements, and integrations to it.

In the next iterations, I am planning to work on these updates:

1. Add support for OpenAI’s GPT-5.5 model for article writing

2. Add support for OpenAI’s ChatGPT Image 2.0 model for image generation

3. Add newsletters so writers can compose daily or weekly emails with AI

4. Add research agents that can help find topics and gather useful information

5. Add the ability to share articles directly to social media

These are just some of the most exciting features I can think of at the moment, and many of them are already in the work pipeline.

I want BloggFast to become more than just a boilerplate. I want it to become a full publishing system for people who want to own their content, move fast, and use AI in a practical way.

Let me know if you have any other features or tools you want to see on BloggFast.

Thank you everyone for the support.

If you want to launch your own blog or news website with full control over the source code, I built BloggFast for you. It is a full-stack NextJS boilerplate built to help you move faster without having to piece everything together from scratch.

Subscribe now

Instead of spending days setting up authentication, the database, CMS, email, hosting, and AI article generation, you can start with a production-ready foundation that already has those core parts wired in. That means you can focus more on building your platform, customizing the experience, and publishing content.

Here’s a quick summary of the steps:

• Step 1: Getting the project

• Step 2: Setting up the environment variables

• Step 3: Set up the database

• Step 4: Testing locally

• Step 5: Deploy the project

In this guide, I will walk through the detailed steps for setting up the project locally and deploying it to production.

Let’s get started.

Step #1: Get the project

The first step is to get access to the BloggFast project files.

Go to blogg.fast and choose the access option that fits your needs: Starter or Lifetime.

If you choose the Starter plan, you will receive an email containing a download link for the project. Open the email, click the link, and download the project as a ZIP archive.

Once the download is complete, extract the archive to a location on your machine where you want to work on the project.

If you choose Lifetime access, your email address will be added to the private GitHub repository automatically. You will receive this email like this:

Open that email and click View repository to access the source code. From there, you can either download the repository as a ZIP file or clone it directly to your local machine using Git.

After downloading or cloning the project, extract the files if needed, and confirm that the full project directory is available locally.

Once that is done, you are ready to continue with the setup.

Step #2: Setting up the environment variables

Open the project folder in your preferred IDE. In this example, I will be using Google Antigravity IDE, but any modern editor, such as VS Code, Cursor, or Antigravity, will work just fine.

Before doing anything else, rename the env.example file to .env. This file will hold all of the local environment variables the application needs in order to run.

Next, open a terminal in the root of the project and install the dependencies:

npm install

This command downloads all the required packages defined in package.json and creates a node_modules folder in the project root. Depending on your internet speed and machine, this may take a minute or two.

Once the installation finishes successfully, the application is ready for configuration.

At this stage, the main goal is to replace the placeholder values in .env with real credentials and service configuration values. BloggFast uses multiple services that work together to power the application, including:

• Database

• Authentication

• Sanity CMS

• Resend email delivery

• Cloudflare R2 storage

• Vercel AI Gateway

Before filling in those values, it is a good idea to connect the project to a remote Git repository and import it into Vercel. This makes the environment setup easier to manage and lets you validate the deployment configuration early.

If you are using GitHub Desktop, create a new private repository for the project and push the local source code to GitHub.

Once the upload is complete, go to Vercel, create a new project, and import the repository. Depending on your account settings, you may need to grant Vercel access to the repository. Follow the prompts shown in the Vercel dashboard.

At this point, you can start an initial deployment.

The build is expected to fail because the environment variables still contain placeholder values, and that is completely normal. The purpose of this first deployment is simply to connect the project to Vercel and prepare the service integrations.

Database setup with Neon

To configure the database, open your Vercel project dashboard and go to the Storage tab. Click Create Database. For this project, use Neon as the database provider.

During setup, make sure to enable Auth. This is important because Neon Auth is used to manage application users and keep authentication data connected to the Postgres database.

When choosing environments, make the database available to all three:

• Development for local work

• Preview for test deployments

• Production for the live application

Once the database is created successfully, you will be redirected to the Neon dashboard.

# Recommended for most uses
DATABASE_URL=postgresql://neondb_owner:npg_XXXXXXXXXXX@ep-fragrant-meadow-XXXXXXXX-pooler.c-6.us-east-1.aws.neon.tech/neondb?channel_binding=require&sslmode=require

# For uses requiring a connection without pgbouncer
DATABASE_URL_UNPOOLED=postgresql://neondb_owner:XXXXXXXX@ep-fragrant-meadow-XXXXXXXX.c-6.us-east-1.aws.neon.tech/neondb?sslmode=require

# Parameters for constructing your own connection string
PGHOST=ep-fragrant-meadow-XXXXXXXX-pooler.c-6.us-east-1.aws.neon.tech
PGHOST_UNPOOLED=ep-fragrant-meadow-XXXXXXXX.c-6.us-east-1.aws.neon.tech
PGUSER=neondb_owner
PGDATABASE=neondb
PGPASSWORD=npg_XXXXXXXX

# Parameters for Vercel Postgres Templates
POSTGRES_URL=postgresql://neondb_owner:npg_XXXXXXXX@ep-fragrant-meadow-XXXXXXXX-pooler.c-6.us-east-1.aws.neon.tech/neondb?channel_binding=require&sslmode=require
POSTGRES_URL_NON_POOLING=postgresql://neondb_owner:npg_XXXXXXXX@ep-fragrant-meadow-XXXXXXXX.c-6.us-east-1.aws.neon.tech/neondb?channel_binding=require&sslmode=require
POSTGRES_USER=neondb_owner
POSTGRES_HOST=ep-fragrant-meadow-XXXXXXXX-pooler.c-6.us-east-1.aws.neon.tech
POSTGRES_PASSWORD=npg_XXXXXXXX
POSTGRES_DATABASE=neondb
POSTGRES_URL_NO_SSL=postgresql://neondb_owner:npg_XXXXXXXX@ep-fragrant-meadow-XXXXXXXX-pooler.c-6.us-east-1.aws.neon.tech/neondb
POSTGRES_PRISMA_URL=postgresql://neondb_owner:npg_XXXXXXXX@ep-fragrant-meadow-XXXXXXXX-pooler.c-6.us-east-1.aws.neon.tech/neondb?channel_binding=require&connect_timeout=15&sslmode=require

Neon provides several database-related environment variables, including DATABASE_URL, pooled and unpooled connection strings, and Postgres-specific values.

From these values, update the corresponding placeholder variables in your local .env file. The most important part here is making sure the application is using the correct database connection string.

Awesome. Now that the database is connected, the next step is configuring Neon Auth.

Neon Auth configuration

In the Neon project dashboard, open the Auth tab and go to the configuration page. Copy the Auth URL and paste it into your .env file as the value for:

Replace the dummy value of the NEON_AUTH_BASE_URL in the .env file.

Next, create a secure value for NEON_AUTH_COOKIE_SECRET. This should be a strong random 256-bit secret. You can generate one using any secure secret generator and paste it into the environment file. I used a Secret Key Generator online tool for this.

Vercel AI Gateway

Next, configure the AI Gateway key.

In your Vercel project, open the AI Gateway section and create a new API key.

Choose a unique name that helps you identify this key and click on the generate button. Copy the API key and replace the dummy value for AI_GATEWAY_API_KEY.

This key allows BloggFast to communicate with the configured AI provider through Vercel’s gateway layer.

Take note also that Vercel gives you a $5 free credits.

Resend email configuration

For email delivery, create a Resend account if you do not already have one. In the Resend dashboard, go to API Keys and create a new key.

Copy the key immediately and update the RESEND_API_KEY variable in your .env file.

For now, you can leave RESEND_WEBHOOK_SECRET unchanged if the application has not yet been deployed to a live URL. That value is usually configured later, once the hosted app is available and can receive webhook events.

Cloudflare R2 storage

BloggFast uses Cloudflare R2 for storing uploaded assets such as article images and generated media.

Create a Cloudflare account if needed, then open R2 Object Storage from the Storage & Databases section. Create a new bucket and choose a clear, permanent bucket name because this name will be part of your storage configuration going forward.

Use:

• Location: Automatic

• Default Storage Class: Standard

After the bucket is created, gather the required values for the following environment variables:

CLOUDFLARE_ACCOUNT_ID
R2_BUCKET_NAME
R2_ENDPOINT
R2_ACCESS_KEY_ID
R2_SECRET_ACCESS_KEY
R2_PUBLIC_BASE_URL
R2_PUBLIC_DEVELOPMENT_URL
NEXT_PUBLIC_MAX_UPLOAD_MB

To get CLOUDFLARE_ACCOUNT_ID and R2_ENDPOINT, go to the R2 overview page and scroll down to Account details. Copy the Account ID and S3 API endpoint.

Set R2_BUCKET_NAME to the exact name of the bucket you created. In this example, I have set it to “bloggfast-storage.”

To create the R2_ACCESS_KEY_ID and the R2_SECRET_ACCESS_KEY, click on the “Manage” button for the API tokens in the same screen above. This will open the Account API Tokens menu. Create an account API token by clicking on the highlighted button below.

Name your token and give it “Admin Read & Write” access. Leave the rest of the settings as the default.

You should now have the Access Key ID and the Secret Access Key. Copy these values and replace the dummy ones in the env file.

To get R2_PUBLIC_DEVELOPMENT_URL, open the bucket settings and enable the Public Development URL option. This gives you a temporary public URL that can be used during development. Copy that generated URL into the environment file.

You can leave R2_PUBLIC_BASE_URL as a placeholder until you attach a custom domain to the bucket later. Then set the NEXT_PUBLIC_MAX_UPLOAD_MB to 100. This helps prevent unexpectedly large uploads from causing issues in development or production.

Sanity set up

Let’s move to the Sanity variables. Head over to Sanity, set up an account, and on the homepage, create a new project.

In the project overview screen, you can see the Project ID. Copy this and replace the NEXT_PUBLIC_SANITY_PROJECT_ID in the env file.

That’s all you need for Sanity for now.

Sync variables to Vercel

Once your local .env file is complete, open the Vercel project dashboard and go to Settings → Environment Variables. Import or manually add the same variables there so that your Preview and Production deployments use the exact same configuration.

This step is important. Local environment variables only affect your machine, while Vercel deployments require the values to be stored in the project settings.

Once everything is saved, the environment setup is complete, and you are ready to initialize the database.

Step #3: Set up the database

With the environment variables configured, the next step is to create the database schema and populate the initial data. At this stage, the process is straightforward: run the Prisma migration command against your target database so Prisma can create the tables, relations, and other schema objects defined by your project.

In Antigravity, go to the terminal and run the command below:

npx prisma migrate dev --name init

If the local generation of the initial migration is successful, you should see this message: “Your database is now in sync with your schema.”

To apply all pending migrations in the target environment, run the command:

  npx prisma migrate deploy

Go back to the Neon project’s page and refresh the Tables dashboard. You should now see all the tables.

Cool. The next step is to populate the database with pre-created content. In the terminal, run the db seed command:

npx prisma db seed

Confirm the success message in the DB seed command. If yes, check if the remote database is populated properly.

Awesome! The database is finally done. The next step is to build and run the project locally.

Step #3: Build and run the project

After the database is set up, the next step is to build the project. This creates an optimized production-ready version of the application that can be deployed to your server or hosting platform.

Run the build command from the root of the project:

npm run build

During this step, the framework compiles the application, checks for build-time issues, and generates the output needed for production. If the build completes successfully, your project is ready for the final deployment steps, such as starting the server or publishing the generated files.

This step is a useful checkpoint because it confirms that the application, configuration, and dependencies are all in a deployable state.

Start the development server so you can preview the project locally:

npm run dev

Now, open http://localhost:3000/ in a browser, and the BloggFast dashboard looks like the image below. You should also see this list of articles.

Toggle the theme to see if the dark mode works correctly.

Alright, everything looks good. It’s time to test the auth and article generation.

Step #4: Testing locally

Before moving to deployment, test the core flows locally to make sure the application, database, and authentication are all working together as expected. For this project, the two main features to verify are login and AI article generation.

Start by running the app locally and opening it in the browser. From there, go through the login flow using a test account. After signing in, confirm that the authentication process completes successfully in the UI and that the user session is created correctly.

Once login succeeds, check your database and Neon Auth dashboard to verify that the user record and related authentication data have been updated as expected.

Next, test the AI article generation flow. To do this, we need to see an admin user. In the Neon User table, change the user role to Admin.

Notice that there is a new “Admin panel” option in the profile menu. This option is only available to administrators.

This will display the admin dashboard. We’ll explore the other tabs next time. For now, leave everything at the default and open the AI Generator tab.

Create a sample article from the app and confirm that the request completes without errors. Here’s a sample prompt:

Prompt: Anthropic releases Claude 4.7 Opus

Click on the publish button, and there should be a success toast message. If the article is published successfully, it should be added to the remote database and will be added to the article list. Here’s a preview of the published content.

The article content and metadata are all synced with the database. The cover image and any other files attached to the article are all uploaded and organized in the R2 bucket.

This local testing step helps verify that the full application flow is working end to end: authentication, database writes, and AI-powered content generation. If both features work correctly and the expected records appear in the database and Neon Auth, the project is in a good state to move forward.

Step #5: Deploy the project

With local testing complete, the final step is to deploy the project to Vercel.

Once the project is configured, trigger the redployment and the project should build successfully.

If your repository stays connected to Vercel, future deployments become much simpler. Vercel automatically creates deployments for branch pushes, while merges to the production branch can be used for production releases. This makes it easy to continue testing in preview environments before promoting changes to the live site. Vercel documents three default environments for this workflow: Local, Preview, and Production.

After deployment, open the production URL and test the same core flows you verified locally, especially login and AI article generation. This final check confirms that the application is working correctly in Vercel with the hosted environment, production variables, and live database connections in place.

That wraps up the project. At this point, you have the database set up, the app tested locally, and the project deployed to Vercel. From here, you can keep iterating, refine the experience, and continue shipping updates with a much smoother workflow.

When you are ready, you can also connect a custom domain in Vercel so your project is available on your own branded URL instead of the default vercel.app address. Vercel supports adding a domain directly from your project settings and guiding you through the DNS configuration needed to point it to your deployment.

With that in place, your application is not only live but ready to be shared more professionally with users, clients, or teammates.

I was at a coffee shop this afternoon when I saw a group of students doing some school activities. One of them was using ChatGPT to create presentation slides. The thing is, ChatGPT cannot really spit out a complete PPT file in one shot in the way many people expect. In many cases, it gives you content, structure, and instructions on how to build each slide manually through Google Slides or Microsoft PowerPoint.

Subscribe now

I am pretty sure a lot of users do this too. They use ChatGPT to brainstorm the title, generate the outline, write the slide content, and sometimes even suggest images or speaking points. That’s great especially for students, freelancers, marketers, and professionals who need to put together a deck quickly. But after the content is generated, the actual work of turning that into a clean, editable, and visually strong presentation often still falls on the user.

Well, let me tell you that there is a better way to do it.

An AI-powered tool called Plus AI can generate a complete presentation from various inputs like a text prompt, a document file, or even a URL. It has hundreds of pre-built designs, so you are not stuck with default templates, and it also has a powerful remix feature that gives you more control over how the content and design should look.

A general AI assistant can be good at generating text, but a specialized presentation tool is designed around the actual workflow of building slides.

Let me tell you more about this product.

It’s an add-on, not an external tool

The main reason why I personally suggest using Plus AI over other tools like ChatGPT, Kimi Slides, or GenSpark is that it is an add-on to existing platforms like Google Slides and Microsoft PowerPoint.

That means the tool is integrated into a platform that you are already familiar with.

• No need to switch between tabs.

• No need to learn a new tool.

• No need to export a file from one website and continue working on another.

That kind of integration is a big deal because most people already know how to use Google Slides or PowerPoint. They already know how to move elements around, change themes, resize images, add animations, and collaborate with others. So instead of spending time adjusting to a new platform, they can stay inside the software they already use and simply enhance it with AI features.

To install, head over to the Google Workspace Marketplace or Microsoft Marketplace and install the Plus AI add-on.

Once installed, a Plus AI menu will appear on the right side of the screen.

What I really love about this product is that you can use it free for a week with zero upfront cost. Not a lot of competitors do this.

You can start from scratch, refine an existing deck, or upload a document for Plus AI to handle both the writing and design.

The modal screen shows a lot of controls. You can adjust the number of slides, the tone of writing, and even the language to use.

A deck that looks simple but communicates well is better than one that looks impressive but feels confusing.

Creating slides with ChatGPT

The whole experience of generating presentation files with ChatGPT is very different from using Plus AI.

For example, if I want to create a pitch deck for my Blogg.fast website, I would ask it like this:

Prompt: Create a 10-slide powerpoint that serves as a pitch deck for my new product blogg.fast

It took the AI almost five minutes to create this incredibly boring presentation. Not much context, terrible design.

To modify the slides properly, I would still have to move everything into Google Slides or Microsoft PowerPoint and manually edit it to my liking. I would need to adjust layouts, shorten sections that are too wordy, improve headlines, replace weak phrasing, insert charts or visuals, and make sure the whole presentation looks cohesive.

This is wayyy too much work compared to generating it with Plus AI.

That is really the biggest difference for me. ChatGPT is very helpful for thinking and writing, but not always the most efficient tool for turning that output into a ready-to-use slide deck.

So… which one to use?

It depends on two things: your workflow and what you value more.

1. If you value time and control over your presentation, pick Plus AI. It is designed to work seamlessly with PowerPoint and Google Slides, so it saves you time in creating slides. It also has more creative options that you can tweak to make something that matches your taste. More importantly, it reduces the amount of manual rebuilding that usually comes after using a general AI tool.

2. If you are already a ChatGPT subscriber and do not want to pay extra, then use ChatGPT. It can analyze uploaded files and also search the web, so you do not have to worry too much about context during the writing stage. It is also great for outlining ideas, rewriting text, and helping you think through what each slide should contain. Just be ready to do a lot of manual retouching and to move your content into other tools for final editing and design work.

In other words, the choice is not really about which tool is universally better. It is more about which one is better for the way you work.

Final Thoughts

Overall, this comparison comes down to how each tool fits into the presentation-making process. ChatGPT is useful for generating ideas, creating outlines, drafting slide content, and helping users think through the message they want to present. Plus AI, on the other hand, is more focused on actually turning that content into a finished presentation inside Google Slides or Microsoft PowerPoint.

Both tools can help, but they help at different stages and in different ways. One is broader and more flexible, while the other is more specialized and presentation-focused.

Personally, I think both tools have clear pros and cons.

ChatGPT is powerful, flexible, and already familiar to many users. It can help a lot with writing, summarizing, researching, and structuring ideas.

Plus AI is not as broad in its capabilities, but that is also why it performs well in this specific use case. It is built around the slide workflow, integrates directly into platforms people already use, and gives more control over design and formatting from the start.

If you are a student or a professional reading this, now is a good time to try the various AI tools available for making presentations. Create the same deck with both, compare the output and the effort required, and see which one fits your style better.

Hi there! Thanks for making it to the end of this post! If you enjoyed this content and would like to support my work, consider becoming a paid subscriber. Your support means a lot!

Support my work

Back in 2024, I had the idea of building my own blog site from scratch.

It is not that I do not enjoy platforms like Medium or Substack. I actually like using them. But at the end of the day, I still do not have full control over the website. I cannot fully customize the UI or UX the way I want, and I am limited by the platform’s system and design decisions.

I also tried building with tools like Webflow and Framer, but I ran into the same issue. They are convenient, but there is still a ceiling when it comes to flexibility and control. On top of that, the monthly subscriptions can add up, and pricing changes are never fun to deal with.

So about a month ago, I decided to stop working around those limitations and just build the thing myself.

That is how BloggFast started.

What is BloggFast

BloggFast is a premium Next.js boilerplate that gives you a fully wired, production-ready AI-powered blog platform out of the box. Instead of spending weeks integrating authentication, a database, a CMS, email, and AI services, you get all of that configured and connected on day one.

I built BloggFast for people who want to launch a serious blog, news site, or content platform without wasting time on repetitive setup work. In my opinion, this is where most developers and creators lose momentum. The excitement is there at the beginning, but once you realize how many moving parts you need just to get a modern content site running, it becomes exhausting very quickly.

The philosophy is simple: buy, configure, ship. You focus on your content and brand, not infrastructure.

This is what the final news/blog website looks like:

You can explore the demo here => https://demo.blogg.fast

Why I Built BloggFast

Personally, I think ownership matters a lot more than people realize. When you own the codebase and the platform, you are free to shape the product however you want. You are not waiting around for another company to add the feature you need. You are not stuck with someone else’s pricing model. And you are not limited by a platform’s built-in design decisions.

Here are the main reasons I built BloggFast:

1. There is nothing quite like it on the market right now. Most AI-driven writing platforms ask you to pay for a recurring subscription while keeping you inside their ecosystem. I think owning the platform is simply the better long-term move.

2. I wanted to help creators publish content faster. AI models are only going to get better at writing, summarizing, researching, and structuring ideas. This product will evolve along with all the AI progress.

3. I also see BloggFast as an evolving product. Over time, I want it to include the best parts of platforms like Sanity, Buffer, Medium, and Substack. It gets tiring having to jump between tools or request features from one platform that only exist in another. My goal is to bring the strongest publishing features together into one solid boilerplate.

4. Another reason is that I wanted to push both my AI workflow and my agentic coding skills further. I have been building products with AI for the past three years, and BloggFast is where I am putting a lot of the best ideas, patterns, and lessons I have learned so far.

5. And of course, I built it to make money too. I would be lying if I pretended otherwise. I make software products for a living, so monetizing something useful that I genuinely believe in is part of the plan.

The Tech Stack

One of the things I care about most when building a product is choosing tools that are practical, modern, and reliable in production.

That is why I picked a stack that is both developer-friendly and scalable. Every tool here serves a purpose: for performance, developer experience, content management, or AI integration.

Here’s the overview of all the provider stack:

• Next.js 16: App Router, React Server Components, and the latest React 19 features.

• Vercel: Easy deploys on Vercel with seamless AI model integration through the Vercel AI Gateway and AI SDK.

• Neon Auth: Passwordless and social login, user management, and sessions built in.

• Neon Database: Serverless Postgres that scales to zero. Branching for dev/staging.

• Prisma ORM: Type-safe database access with auto-generated queries and migrations.

• Sanity IO: Headless CMS with real-time collaboration and a customizable studio.

• Multiple selectable LLMs: Including Claude 4.6 Sonnet, Claude 4.6 Opus, GPT-5, Gemini 3.1 Pro, DeepSeek, and Minimax — configurable from the admin dashboard for article generation.

• AI Image models: Generate blog cover images with Nano Banana Pro, GPT-image-1.5, or Flux Pro in multiple aspect ratios, directly from the article editor.

• Cloudflare: Edge-ready asset delivery and storage support for media, uploads, and performance.

• Resend: Transactional emails for welcome flows, notifications, and newsletters.

• TypeScript: Fully typed codebase. Catch bugs at build time, not in production.

It is modern without being overly experimental, and powerful without becoming unnecessarily complicated.

Setting up BloggFast

Getting started with BloggFast is straightforward. There are two ways to get the boilerplate:

1. Download the project as a *.zip file.

2. Become a member of the private GitHub repo and get access to lifetime updates to the project.

If you choose the GitHub option, I recommend forking the project first and making sure your fork stays synced with the remote repository.

Here’s the project layout:

bloggfast/
├── prisma/
│   ├── schema.prisma          # Full database schema (17 models, 6 enums)
│   └── seed.ts                # Seed script for initial data
├── public/                    # Static assets (images, fonts, icons)
├── sanity/
│   └── schemas/               # Sanity content type definitions
│       ├── post.ts            # Blog post schema
│       ├── author.ts          # Author schema
│       ├── category.ts        # Category schema
│       └── index.ts           # Schema registry
├── src/
│   ├── app/
│   │   ├── (marketing)/       # Public blog pages
│   │   │   ├── page.tsx       # Homepage with article feed
│   │   │   ├── article/[slug] # Individual article pages
│   │   │   ├── category/[slug]# Category listing pages
│   │   │   ├── tag/[slug]/    # Tag listing pages
│   │   │   ├── author/[slug]/ # Author profile pages
│   │   │   ├── latest/        # Latest articles
│   │   │   ├── trending/      # Trending articles
│   │   │   ├── editors-pick/  # Editor’s pick articles
│   │   │   ├── search/        # Search page
│   │   │   └── layout.tsx     # Marketing layout (navbar + footer)
│   │   ├── (admin)/           # Protected admin dashboard
│   │   │   ├── admin/
│   │   │   │   ├── page.tsx           # Dashboard overview + stats
│   │   │   │   ├── articles/          # Article list, create, edit
│   │   │   │   ├── categories/        # Category management
│   │   │   │   ├── authors/           # Author management
│   │   │   │   ├── tags/              # Tag management
│   │   │   │   ├── subscribers/       # Email subscriber management
│   │   │   │   ├── generate/          # AI article generator
│   │   │   │   ├── generation-history/# AI generation history
│   │   │   │   └── settings/          # Site & AI settings
│   │   │   └── layout.tsx             # Admin layout (sidebar nav)
│   │   ├── (app)/             # Authenticated user pages
│   │   │   ├── profile/       # User profile page
│   │   │   ├── saved/         # Saved articles
│   │   │   ├── liked/         # Liked articles
│   │   │   └── layout.tsx
│   │   ├── (auth)/            # Auth pages
│   │   │   ├── sign-in/[[...stack]]/  # Sign in page
│   │   │   ├── sign-up/[[...stack]]/  # Sign up page
│   │   │   └── layout.tsx
│   │   ├── auth/[path]/       # Custom auth path handler
│   │   ├── studio/            # Embedded Sanity Studio
│   │   │   ├── [[...tool]]/   # Catch-all for Studio routes
│   │   │   └── layout.tsx     # Studio layout
│   │   ├── api/               # API route handlers
│   │   │   ├── auth/          # Neon Auth API endpoints
│   │   │   ├── generate/      # AI article generation endpoint
│   │   │   ├── generate-image/# AI cover image generation endpoint
│   │   │   ├── search/        # Article search endpoint
│   │   │   ├── subscribers/   # Email subscription endpoints
│   │   │   ├── views/         # Article view tracking endpoint
│   │   │   ├── rss/           # RSS feed endpoint
│   │   │   └── webhooks/      # Resend webhook handler
│   │   ├── layout.tsx         # Root layout (providers, fonts, theme)
│   │   ├── globals.css        # Global CSS with Tailwind v4 imports
│   │   ├── sitemap.ts         # Dynamic sitemap generation
│   │   ├── robots.ts          # robots.txt configuration
│   │   ├── error.tsx          # Global error page
│   │   ├── loading.tsx        # Global loading UI
│   │   └── not-found.tsx      # 404 page
│   ├── components/            # Reusable UI components
│   │   ├── ui/                # shadcn/ui base components
│   │   ├── admin/             # Admin dashboard components
│   │   ├── articles/          # Article card, detail, engagement
│   │   ├── layout/            # Navbar, footer, sidebar, theme toggle
│   │   ├── search/            # Search modal and input
│   │   ├── providers.tsx      # App-level context providers
│   │   └── subscribe-form.tsx # Newsletter subscription form
│   ├── actions/               # Next.js Server Actions
│   │   ├── articles.ts        # Article CRUD operations
│   │   ├── admin.ts           # Admin-specific operations
│   │   ├── ai-settings.ts     # AI configuration operations
│   │   ├── engagement.ts      # Engagement tracking
│   │   └── subscribe.ts       # Subscription management
│   ├── lib/
│   │   ├── db/
│   │   │   ├── index.ts       # Prisma client singleton (Neon adapter)
│   │   │   └── queries.ts     # Database query functions
│   │   ├── ai/
│   │   │   ├── generator.ts   # Article generation with OpenAI
│   │   │   ├── prompts.ts     # System prompts for AI generation
│   │   │   └── ai-settings-schema.ts  # AI settings Zod schema
│   │   ├── auth/
│   │   │   ├── neon-server.ts # Neon Auth server-side client
│   │   │   ├── neon-client.ts # Neon Auth client-side hooks
│   │   │   └── server.ts      # Auth helper functions
│   │   ├── sanity/
│   │   │   ├── client.ts      # Sanity client + image URL builder
│   │   │   └── queries.ts     # GROQ query functions
│   │   ├── resend.ts          # Email sending functions (Resend)
│   │   ├── unified-queries.ts # Cross-source article queries
│   │   ├── article-utils.ts   # Article helper utilities
│   │   ├── constants.ts       # Shared enum constants
│   │   └── utils.ts           # General utilities
│   ├── sanity/                # Sanity runtime config (imported by Studio)
│   │   ├── schemaTypes/       # Portable Text content type definitions
│   │   ├── lib/               # Sanity client, image, live helpers
│   │   ├── structure.ts       # Studio structure config
│   │   └── env.ts             # Sanity environment variables
│   ├── types/                 # Shared TypeScript type definitions
│   ├── hooks/                 # Custom React hooks
│   ├── env.ts                 # Type-safe env validation (@t3-oss/env-nextjs)
│   └── middleware.ts          # Auth middleware (protects /admin, /profile, etc.)
├── .env.example               # Environment variable template
├── next.config.ts             # Next.js config (React Compiler, image domains)
├── sanity.config.ts           # Sanity Studio config file
├── sanity.cli.ts              # Sanity CLI config
├── prisma.config.ts           # Prisma config
├── components.json            # shadcn/ui component registry config
├── package.json
└── tsconfig.json

Once you have the project on your local machine, unzip it and follow the documentation page.

Make sure all environment variables are configured correctly and that the build passes successfully. After that, run the database seed to populate the app with temporary sample data, then start the development server with npm run dev.

Once everything is working, open http://localhost:3000/ and you should see the following screen:

At this point, you already have a working foundation. That is a huge difference compared to starting from scratch, where even getting to this stage can take a lot of time.

In the next section, I will walk through the admin pages and show how article generation works with AI.

BloggFast’s Admin Pages

The admin side of BloggFast is where you control the platform: from managing articles and settings to configuring AI models and custom skills.

First, there is the Dashboard page, which gives you a summary of the articles that have already been created. From here, you can quickly edit existing content or generate a new article.

Take note that the admin page is only accessible to users with an Editor or Admin role. In the Neon database table, you can set which user is an admin or editor.

In the Settings page, you can configure your AI model providers. Right now, I have added support for frontier models such as GPT-5, Claude 4.6 Sonnet, Claude 4.6 Opus, DeepSeek V3, and MiniMax M2.7.

For image generation, I added support for Flux 2 Pro, Nano Banana Pro, and GPT-Image-1.5. Based on my own testing, the best combination so far is Claude 4.6 Sonnet for writing and Flux 2 Pro for images.

Another feature I am really happy with is the ability to add customizable AI skills. Inside the AI Skills tab, you can create a new skill and describe exactly how it should behave. For example, the FAQ writer skill shown in the screenshot below automatically adds an FAQ section to the end of every article.

You can also enable or disable multiple skills at the same time.

Alright, now let’s move on to the AI article generator.

Generating articles

Open the AI Generator tab. This is what the dashboard looks like:

In the prompt field, describe the article you want to generate. Then set the additional parameters such as article length, category, author, and whether you want to automatically generate a cover image and AI summary.

Here’s an example topic:

Prompt: Alibaba claims viral happy horse AI model in latest breakthrough

In as little as 15 seconds, you get a well-researched output complete with reference links, an AI summary, and a cover image.

From there, you can publish the article immediately or manually refine it by clicking the Edit button in the upper-right corner.

I also made sure the editor supports more than just plain text. You can insert images, videos, and documents into the article, and URLs are rendered properly.

For devs, you can also add code blocks in any programming language, which makes the platform flexible enough for technical writing too.

Files such as images and videos are uploaded to Cloudflare R2 instead of being stored as Vercel blobs. That decision matters a lot because it helps reduce storage costs and improves performance at the same time.

The uploaded files are also organized cleanly inside the R2 bucket and synced with the Neon database.

This is what the published article looks like:

And just like that, a complete blog post about Alibaba’s new HappyHorse Video AI model can be published in under a minute. If I had done the whole thing manually, it probably would have taken me at least an hour.

That speed is exactly why I believe tools like this are worth building. They do not replace taste, editing, or good judgment, but they absolutely remove a lot of repetitive work.

You can read the published article here => https://demo.blogg.fast/article/alibaba-reveals-it-built-the-viral-happyhorse-video-ai-model

Check out the video below to see a more detailed process of how the article generation with AI works:

A few things to remember

Before wrapping up, I want to answer a few common questions that people usually have when they see a product like this for the first time. I think it is important to be clear about what BloggFast is, what you actually get, and who this product is best suited for.

• What do I get exactly? You get the complete source code for a production-ready AI-powered blog built with Next.js 16. This includes authentication, database setup, CMS integration, AI article generation, email system, and beautiful UI components.

• How often is BloggFast updated? I ship updates regularly — typically every 1–3 days. Updates include new features, dependency upgrades, security patches, and improvements based on customer feedback.

• Is this a website template? No, BloggFast is much more than a template. It’s a fully functional Next.js application with backend logic, database schemas, API routes, authentication, CMS integration, and AI-powered content generation. Think of it as a complete product you can customize and deploy — not just a static design.

• JavaScript or TypeScript? BloggFast is built entirely in TypeScript for maximum type safety and developer experience. Every component, API route, and utility is fully typed. If you prefer JavaScript, TypeScript is fully compatible — you can gradually adopt it or remove types as needed.

• Can I use this for multiple projects? Yes! Your license covers unlimited projects for personal or commercial use. Build as many blogs, news sites, or content platforms as you want. No per-project fees, no recurring charges.

• Do I need to know Next.js to use this? Basic familiarity with React and Next.js is helpful, but you don’t need to be an expert. The codebase is well-structured and documented. Most customizations — like changing colors, content, and branding — are straightforward. For bigger changes, Next.js knowledge will help you get the most out of the boilerplate.

  Generative AI Publication is a reader-supported publication. To receive new posts and support my work, consider becoming a free or paid subscriber.

Final Thoughts

To wrap things up, BloggFast is the product of everything I discussed in this article: the idea of owning your platform, moving faster with AI, and having full control over how your blog or news site looks and works.

I built it because I wanted a better alternative to the usual publishing platforms and subscriptions. I wanted something that creators, developers, indie makers, and founders could actually own and customize without being locked into someone else’s ecosystem.

BloggFast is for people who have always wanted to launch their own content platform but did not want to spend weeks or months wiring everything together from scratch.

One of the things I really wanted to achieve with this product was simplicity. Setup is straightforward, the stack is already connected, and the app gives you the tools to generate articles, manage content, customize AI workflows, and launch a production-ready blog much faster than doing everything manually.

The bigger idea here is freedom.

Instead of paying ongoing platform fees and adjusting your workflow around other companies’ limitations, you can build and grow a site that is fully yours. If you want to launch a personal blog, a niche media site, a newsletter-driven publication, or an AI-assisted content business, BloggFast gives you a really good starting point.

Right now, I am offering BloggFast at 50% off, so this is a great time to try it out and see what you think. If you run into any issues or have questions, feel free to email me at jimclydegm@gmail.com for support.

Thank you so much for the continued support. I really appreciate it.

Check out BloggFast now => https://www.blogg.fast

Hi there! Thanks for making it to the end of this post! If you enjoyed this content and would like to support my work, consider becoming a paid subscriber. Your support means a lot!

Support my work

NVIDIA announced NemoClaw at GTC 2026 less than a week ago. It’s a security wrapper for OpenClaw, the open source AI agent platform that became the fastest growing open-source project in history, but got plagued with security concerns. Kernel-level sandboxing, a deny-by-default policy engine, and a privacy router.

One group of researchers called it a “lethal trifecta.”

Subscribe now

NemoClaw is NVIDIA’s response. It wraps OpenClaw inside the OpenShell runtime with three layers of protection:

• A kernel-level sandbox using Landlock, seccomp, and network namespaces

• An out-of-process policy engine that agents supposedly cannot override

• A privacy router that keeps sensitive data on local Nemotron models while routing complex queries to cloud APIs

Zack Korman, a cybersecurity professional and CTO at Pistachio, started poking at Nemoclaw. Korman’s background is in threat detection, and he has a law degree from Edinburgh and a master’s from Oxford, so he knows how to read documentation carefully.

The Vulnerability Korman Found

Read more

OpenAI’s pre-IPO investor document landed this week, and the most interesting part isn’t the $830 billion valuation target or the Q4 2026 IPO timeline. It’s the section where OpenAI tells prospective investors, in writing, that Microsoft is a risk to their business.

The filing reads:

“If Microsoft modifies or terminates its commercial partnership with us, or if we are unable to successfully diversify our business partners, our business, prospects, operating results and financial condition could be adversely affected.”

That’s the company that gave OpenAI $13.8 billion, most of its compute, and its primary distribution channel being formally listed as a threat.

It’s crazy.

How We Got Here

Read more

Manus has been a cloud-first AI agent since its launch in March 2025. You give it a task, it opens a sandboxed environment, browses the web, writes code, and delivers results. But there was one big limitation—it could not touch your local machine.

Subscribe now

That changes today.

Manus released My Computer, the core feature of a new Desktop app that gives the agent direct access to your files, terminal, applications, and hardware. It is available now on macOS and Windows.

This is the first major product release since Meta acquired Manus for roughly $2 billion in late 2025.

What Is My Computer?

My Computer is a feature inside the new Manus Desktop app. It extends Manus from a cloud-only agent into one that can operate directly on your local machine.

Read more

After weeks of rumors, Jensen Huang finally revealed NemoClaw during NVIDIA GTC 2026 as a security focused layer for the OpenClaw ecosystem. The goal is to autonomous agents safer to run without limiting what they can do.

Subscribe now

OpenClaw went viral in a matter of weeks and that momentum also exposed a bunch of security concerns. Agents often run with broad permissions, which makes data access and execution harder to control in practice.

NVIDIA’s answer is NemoClaw.

What is NemoClaw?

It is a runtime layer that sits on top of OpenClaw and enforces how agents behave. It does not replace OpenClaw. It constrains it.

You still get autonomous agents, but they run inside a controlled environment with explicit rules for data access, network calls, and execution.

NVIDIA implements this using OpenShell, which acts as the secure execution layer. Every agent runs inside a sandbox, and every action passes through policy checks. That includes file access, outbound requests, and model inference.

Here’s what the NemoClaw workflow looks like:

Read more

OpenClaw went from zero to 314,000 GitHub stars in under four months. It surpassed React. It surpassed Linux. It became the most-starred non-aggregator software project on GitHub, period.

Subscribe now

But OpenClaw is no longer alone.

In the eight weeks since it exploded, the “Claw” ecosystem has spawned at least nine serious open-source AI agent projects, each attacking a different slice of the problem. Rust rewrites. Go ports for $10 hardware. Container-isolated forks built specifically to fix OpenClaw’s security nightmares.

Now there’s a live scoreboard tracking the whole thing. ClawCharts is a free, real-time analytics dashboard that ranks every major Claw project by star growth, contributor activity, and commit velocity.

What Is ClawCharts?

ClawCharts pulls live data from the GitHub API and ranks projects using a composite momentum score. The primary drivers are seven-day stars gained (plus percentage change), seven-day contributors (plus percentage change), and seven-day commits (plus percentage change). Total stars serve as a tiebreaker.

This is what the dashboard looks like:

Read more

Paul Conyngham didn’t go to medical school. He runs a machine learning consultancy in Sydney, spends most of his time with data pipelines and prediction models, and has no formal background in biology or oncology. But when his rescue dog Rosie was diagnosed with aggressive mast cell cancer in 2024 and given only months to live, he did something that most researchers would have called impossible for a non-specialist: he used AI to design her a custom cancer vaccine.

Subscribe now

The tumor on Rosie’s back leg shrank by more than 50% within one month of her first injection. She is alive and, by all accounts, chasing rabbits again.

I’ve been covering generative AI for a while now, and I’ve watched it get applied to code generation, legal documents, financial modeling, and drug discovery at the institutional level. But this story cuts differently. It’s a single person, working mostly alone, who took tools that were publicly available and used them to do something that had never been done before for a dog. The implications for human medicine are hard to overstate.

The Dog Who Started It All

Rosie is a Staffordshire Bull Terrier and Shar Pei cross. Conyngham adopted her from a Sydney shelter in 2019, after she had been abandoned in bushland. He describes her as his closest companion through some of the hardest stretches of his life.

In 2024, large tumors appeared on one of her back legs. The diagnosis was mast cell cancer, the most common skin cancer in dogs and notoriously difficult to treat once it spreads beyond the initial site. Conyngham spent thousands of dollars on veterinary chemotherapy and surgical intervention. The treatments slowed the cancer. They did not shrink the tumors.

He started thinking about a different approach.

How ChatGPT Became a Biomedical Research Partner

Read more

There’s a reason OpenClaw became one of the fastest-growing open-source projects in history. Within 60 days of its January 2026 release, it gained over 250,000 GitHub stars, outpacing the growth of major projects like React and even Linux in a fraction of the time.

Subscribe now

People became excited because this AI companion runs locally on your computer. It can acce…

Read more

Google’s AI-powered marketing tool Pomelli just expanded its availability to over 170 countries and territories, making it accessible to a much wider audience of businesses and creators.

Subscribe now

Pomelli is an experimental AI-powered marketing tool from Google Labs, developed in collaboration with DeepMind. It’s designed to help small-to-medium-sized businesses (SMBs) automatically generate on-brand social media campaigns, ads, and marketing visuals with minimal effort.

Instead of manually building brand kits or designing campaigns from scratch, Pomelli simply asks for a website URL. It then scans the site and constructs what Google calls a “Business DNA”. From there, the AI generates customized, editable marketing materials that stay consistent with your brand.

Key Features

• Automatic Brand Analysis: Pomelli scans your website and automatically identifies your logos, fonts, color schemes, imagery, and tone of voice.

• On-Brand Content Generation: Using the extracted brand information, the tool generates social media posts, ads, and campaign ideas tailored specifically to your brand style.

• AI Image Enhancement: It can turn basic product photos into studio-quality marketing visuals, complete with AI-generated backgrounds and lighting.

• Editable Assets: All generated content remains fully editable, allowing you to tweak text, colors, and visuals before exporting.

• Free Experimental Access: Currently, Pomelli is available as a free experimental tool through Google Labs, though it was previously limited to users in the United States.

Creating Marketing Assets with Pomelli

Head over to Google Labs and look for the Pomelli tool. Take note that you need to be logged in with your Google account to be able to use it.

Read more

You can now use ChatGPT to build, update, and analyze spreadsheets faster in MSFT Excel. It’s an Excel add-in that brings ChatGPT directly into workbooks, helping users run scenarios and generate outputs based on cells and formulas.

Subscribe now

Here’s how it works:

1. Build and update spreadsheet models faster: Describe what you need in plain language and ChatGPT will create or update live Excel models while preserving formulas, structure, and assumptions.

2. Get insights from large spreadsheets: ChatGPT analyzes how sheets and formulas connect, explains changes in results, and traces or fixes errors in complex workbooks.

3. Follow the logic and trust the outputs: ChatGPT links answers to the exact cells it uses and asks permission before making edits, so teams can audit formulas and verify results.

The tool is powered by GPT-5.4 and can be installed from the Add-in tab in the web version of MSFT Excel.

Read more

You can now use ChatGPT to build, update, and analyze spreadsheets faster in MSFT Excel. It’s an Excel add-in that brings ChatGPT directly into workbooks, helping users run scenarios and generate outputs based on cells and formulas.

Subscribe now

Here’s how it works:

1. Build and update spreadsheet models faster: Describe what you need in plain language and ChatGPT will create or update live Excel models while preserving formulas, structure, and assumptions.

2. Get insights from large spreadsheets: ChatGPT analyzes how sheets and formulas connect, explains changes in results, and traces or fixes errors in complex workbooks.

3. Follow the logic and trust the outputs: ChatGPT links answers to the exact cells it uses and asks permission before making edits, so teams can audit formulas and verify results.

The tool is powered by GPT-5.4 and can be installed from the Add-in tab in the web version of MSFT Excel.

Read more

Given Microsoft’s massive, multi-billion-dollar investments in AI over the past couple of years, Copilot was positioned to be the ultimate productivity game-changer. It promised advanced automation workflows that would save professionals countless hours. Add in their undeniable home-field advantage, Microsoft literally owns and built PowerPoint, and you…

Read more

Google’s new Nano Banana 2 image model is here. It’s as powerful as the Pro model at half the price, making it the perfect tool for batch image generation without compromising the quality.

Subscribe now

The model is now leading the text-to-image ranking on Arena AI.

Key technical highlights of Nano Banana 2:

• Base architecture is based on the Gemini 3.1 Flash image model

• Supports native 4K output, similar to the Pro model

• It can handle complex spatial instructions, like “a red car between two blue trucks,” that the original model would have trouble with.

• Uses Google Search data to render current events, real-world subjects, and accurate facts in its output

• 50% cheaper than Nano Banana Pro

• Supports new aspect ratios like 1:4, 4:1, 1:8, and 8:1

One noteworthy capability is the support for up to 14 image inputs. For example, you can upload a bunch of animal images and ask Nano Banana 2 to put all of them in a farm.

Prompt: Joyful characters and items at a farm

Read more

On February 19, 2026, the Financial Times published a report that Amazon Web Services (AWS), the backbone of much of the modern internet, had suffered outages caused by its own AI coding tools — including an “agentic” assistant called Kiro that allegedly decided the best way to fix a problem was to delete an entire environment.

Subscribe now

The story quickly went viral. It tapped into deep-seated fears about handing over critical infrastructure to autonomous AI. Yet less than 24 hours later, Amazon fired back with an unusually detailed public correction, insisting the entire narrative was wrong — and that the real culprit was classic human error, not rogue AI.

What really happened?

The Financial Times Report

According to the Financial Times, citing four people familiar with the matter (including current Amazon employees), AWS experienced a 13-hour interruption in mid-December 2025 to AWS Cost Explorer — the customer-facing dashboard that helps users visualize, understand, and manage their cloud spending.

Read more

Google just dropped a new version of its AI music generator tool, Lyria. This new version is capable of producing a 30-second track from various inputs like text descriptions, photos, and even videos.

Subscribe now

The AI music scene has mainly been nominated by platforms like Suno and Udio. Since their explosive rise in 2024, they’ve set the bar high:

• Suno is really good at quick, catchy full-length songs

• The recent version of the music model can produce up to 8+ minutes per track with a strong pop/viral appeal

• Udio often edges out in raw audio fidelity, vocal realism, and studio-like controls (e.g., inpainting, extensions for longer tracks up to 15 minutes).

Lyria 3, in contrast, can only produce a 30-second track per generation. But according to Google, this model creates high-fidelity AI music complete with instrumentals, vocals, and lyrics.

How Lyria 3 compares to the previous versions

The original Lyria model was launched in late 2023 as part of Google DeepMind’s experiments, like Music AI Sandbox (for pro musicians) and YouTube’s Dream Track feature.

Lyria 2 followed around 2025, adding refinements like better control, real-time capabilities (Lyria RealTime), and API access via Vertex AI. It was mostly instrumental-focused and geared toward developers or integrated tools.

And now we have Lyria 3 in 2026.

Here are the main improvements of Lyria 3 over the previous versions:

Read more

OpenClaw has been dominating my newsfeed in the past couple of days. It’s what every AI enthusiast has been talking about — building all kinds of projects and experimenting with every possible use case they can do with this automation system.

Subscribe now

In case you didn’t know it yet, OpenClaw is an open-source autonomous agent designed to act as a proactive AI assistant. Unlike standard chatbots that wait for you to ask a question, OpenClaw runs as a persistent service on your own hardware (like a Mac Mini, or even a private server) and can perform real-world tasks independently.

People have been using it to execute actions like remotely vibe coding apps, automating the generation of TikTok videos, controlling smart home devices, or performing web automation.

What makes it super cool is that you can interact with it through everyday apps like WhatsApp, Telegram, Discord, and Slack.

Here’s a quick summary of facts about OpenClaw:

1. OpenClaw started as a weekend side project

2. OpenClaw is the fastest-growing open-source AI project in history

3. What makes OpenClaw unique is the “Heartbeat” feature

4. It underwent three major rebrands following trademark concerns from Anthropic

5. OpenClaw is powered by Claude, but its creator joined OpenAI instead of Anthropic

Let’s get into the details.

Read more