DEV Community: Boudy de Geer

My Manifesto Against AI "Ping-Pong" & Token Waste (and the Project Intelligence Platform I'm Building in Public to Fix It)

Boudy de Geer — Tue, 21 Oct 2025 14:09:43 +0000

I'm tired of burning $100/mo on wasted AI tokens just to build a single feature. So I'm building the solution. This is Day 1.

Hey everyone,

Like many of you, I use AI tools like the Claude Code CLI and Gemini CLI daily. They're incredibly powerful, but let's be honest: they're also a massive drain on time and money.

I found myself trapped in a constant "ping-pong" match. 20+ prompts just to get one simple feature halfway done. Explaining the context over, and over, and over again. And the cost? I was burning over $100 per month just on repeated context tokens – information the AI should already know!

My side projects were stalling. I have 3 SaaS ideas I know could be real businesses, but with only 2-3 hours a day after my job, spending 80% of that time wrestling with AI context just wasn't sustainable. Six months later? Nothing launched.

The Real Problem: It's Not the AI, It's the Orchestration!

I realized the issue isn't the Large Language Models themselves. They're amazing. The problem is the lack of memory between sessions and, more importantly, the lack of intelligent orchestration. We're getting "vibe coding" at light speed – fast prototypes, faster tech debt, and ultimately, chaos.

Copilot only autocompletes. ChatGPT requires endless copy-pasting. Even powerful CLIs lack project-level intelligence.

The Solution: Building the Co-Founder I Always Wanted
So, I stopped complaining and started building: MOSAIQO.

MOSAIQO isn't just another AI assistant. It's a Project Intelligence Platform designed to sit on top of tools like Claude and Gemini.

What does it do differently? It EXECUTES.

Imagine this:

You (at a cafe):

"I want to add Stripe payments."

MOSAIQO:

✓ Analyzes your codebase.
✓ Uses AI Planning to generate the necessary tasks (e.g., 12 steps).
✓ Uses smart RAG to feed ONLY the relevant context for EACH task (saving ~95% tokens).
✓ Orchestrates agents (Claude/Gemini) using your API keys to implement the code.
✓ Enforces TDD and quality gates.
✓ Updates your documentation hub.
✓ Creates a Pull Request.

You (30 minutes later):

Review and approve.
Result: 3 hours & $8 in tokens → 30 mins & $0.40 in tokens.

The 3 Unique Game-Changers:

MOSAIQO is built around three core pillars nobody else is combining effectively:

Remote + Multi-Workers: Install lightweight "worker" apps on your home Mac, a cheap VPS, anywhere. Assign tasks from your laptop, and your distributed team of AI agents executes them in parallel, 24/7, using hardware you already own. Work from anywhere, build anytime, without burning your laptop or cloud credits.

Full Lifecycle (Idea → Production): From brainstorming and refining your initial idea with AI Planning, to generating a full project roadmap, orchestrating the implementation, and even...

Auto-Fix Production Bugs: Connect MOSAIQO to Sentry (or similar). When a bug hits at 3 AM, MOSAIQO automatically analyzes it, writes the fix, implements the test, creates the PR, and notifies you. You wake up, review, merge, deploy. Hours of debugging → 5 minutes.

This Isn't Just a Tool, It's a Rebellion
MOSAIQO is my manifesto against "vibe coding," wasted tokens, and ideas dying in notebooks. It's built for developers with side projects, non-technical entrepreneurs, and small startups who need to move fast without sacrificing quality.

And because you run the workers and can bring your own API keys (BYOK), the margins are insane, allowing for affordable pricing ($12-$59/mo for early birds) with a ridiculous ROI for you.

Join the Journey (Build in Public)

Yesterday, I launched the official countdown on mosaiqo.dev. It's more than a clock; it's my public promise to build the core MVP over the next two weeks, sharing the code, the bugs, and the breakthroughs along the way.

The waitlist for the first pioneers opens on November 3rd.

This is Day 1. This is the rebellion.

If you're tired of the AI "ping-pong" and burning money on tokens, if you believe there's a better way to build with AI... join me.

Follow the daily journey on Twitter: @boudydegeer

Join the countdown at: mosaiqo.dev

I'd love your honest feedback on this vision. Are you feeling this pain too? What are your thoughts? Let me know in the comments!

Authentication in Nuxt3 with Sidebase Nuxt-Auth

Boudy de Geer — Tue, 13 Feb 2024 09:12:33 +0000

This tutorial aims to simplify the process of adding robust authentication mechanisms, whether you're looking to implement social logins, email verification, or traditional username and password authentication.

This is the official GitHub, go ahead and give them some love by ⭐️ it.

sidebase · GitHub

High quality open-source software to kick-start your development - sidebase

github.com

Introduction to Sidebase Nuxt-Auth

Sidebase Nuxt-Auth is a powerful authentication module tailored for Nuxt3 applications. It facilitates the integration of diverse authentication methods, making your application secure and accessible.
Here you can find the documentation thanks to @danielroe and all other devs that maintain and contribute to the project

Getting Your Project Ready

Before diving into the authentication setup, make sure you have a Nuxt3 application up and running. If you're just starting, here's how to create a new Nuxt3 project:

npx nuxi init nuxt3-app
cd nuxt3-app
npm install

Next, add the necessary authentication packages to your project:

npm install @next-auth/prisma-adapter next-auth @prisma/client bcrypt

Configuring Sidebase Nuxt-Auth

The core of setting up Sidebase Nuxt-Auth lies in its configuration.

Let's break it down:

Step 1: Authentication Handler Setup

Initialize the NuxtAuthHandler with your secret and session strategy:

import { NuxtAuthHandler } from '#auth'

export default NuxtAuthHandler({
  secret: 'A_Strong_Secret',
  session: { strategy: 'jwt' },
});

Step 2: Adding Authentication Providers

Sidebase Nuxt-Auth supports various providers. Here's how to add some common ones:

Email Provider:

EmailProvider({
  server: process.env.EMAIL_SERVER,
  from: process.env.EMAIL_FROM,
});

Social Providers (e.g., GitHub, Google):

GithubProvider({
  clientId: process.env.GITHUB_CLIENT_ID,
  clientSecret: process.env.GITHUB_CLIENT_SECRET,
});

Step 3: Customizing Authentication Pages and Callbacks

Specify custom routes for authentication actions in your configuration:


pages: {
  signIn: '/auth/login',
  signOut: '/auth/logout',
};

Use callbacks for additional control over the authentication flow:


callbacks: {
  async signIn({ user }) {
    // Custom logic here
    return true;
  },
};

Securely Storing Secrets

Remember to use environment variables for storing sensitive information like client secrets, avoiding hard-coded values in your source code.

Implementing User Registration
A crucial part of managing user authentication is allowing users to register. Here's a basic overview:

Define an Event Handler:

Start by creating an event handler that processes registration requests:


import { hash } from 'bcrypt';

export default defineEventHandler(async (event) => {
  // Registration logic here
});

Read and Validate User Input:

Ensure the provided information is valid and the user doesn't already exist:


const body = await readBody(event);
const userExists = /* logic to check if user exists */;
if (userExists) {
  // Handle existing user case
}

Store User Credentials Securely:

Hash the user's password and store the new user in the database:


const hashedPassword = await hash(body.password, 10);
// Logic to create user record

Final Thoughts

Integrating Sidebase Nuxt-Auth enhances your Nuxt3 project's security and user experience by offering a streamlined authentication system. By following the steps outlined, you can set up a versatile authentication system that caters to a wide range of use cases.

Remember, the effectiveness of your authentication system not only lies in its setup but also in regular maintenance and adherence to security best practices.

Thanks 👋 for reading and supporting!

Getting Started with Nuxt 3

Boudy de Geer — Fri, 09 Feb 2024 10:28:37 +0000

Hey there! If you're curious about building web apps that shine, you're in the right spot. Nuxt 3 is here to transform your ideas into reality, no matter your experience level. It's the newest family member of the Vue.js universe, crafted to streamline your development process from start to finish. So, whether you're just starting your coding adventure or you're a seasoned pro eager to explore what Nuxt 3 has in store, this guide is your companion. Together, we'll have a look at the features that make Nuxt 3 a game-changer.

First let me thank @atinux,@danielroe, @pi0, and all +630
contributors and maintainers (at the time of this writing)

This is the official GitHub, go ahead and give them some love by ⭐️ it.

nuxt / nuxt

The Intuitive Vue Framework.

Nuxt

Nuxt is a free and open-source framework with an intuitive and extendable way to create type-safe, performant and production-grade full-stack web applications and websites with Vue.js.

It provides a number of features that make it easy to build fast, SEO-friendly, and scalable web applications, including:

Server-side rendering, Static Site Generation, Hybrid Rendering and Edge-Side Rendering
Automatic routing with code-splitting and pre-fetching
Data fetching and state management
SEO Optimization and Meta tags definition
Auto imports of components, composables and utils
TypeScript with zero configuration
Go fullstack with our server/ directory
Extensible with 200+ modules
Deployment to a variety of hosting platforms
...and much more 🚀

🚀 Getting Started

Use the following command to create a new starter project. This will create a starter…

View on GitHub

Ready to get started?

Great! Let's dive in 🤿.

What is Nuxt 3?

Nuxt 3 is a progressive Vue.js framework used for building modern web applications. It provides an out-of-the-box setup for server-side rendering, static site generation, and single-page applications, making it incredibly versatile for developers. With Nuxt 3, you can enjoy the benefits of Vue.js, such as its reactive components, and enhance your development experience with Nuxt's powerful features and plugins.

Setting Up Your First Nuxt 3 Project

Getting started with Nuxt 3 is straightforward. Follow these steps, and you'll have your first Nuxt 3 project up and running in no time.

Prerequisites

Before we begin, ensure you have Node.js (version 14 or later) installed on your computer. You can check your current Node.js version by running node -v in your terminal. If you need to install or update Node.js, visit Node.js official website for download instructions.

Step 1: Create a Nuxt 3 Project

Open your terminal and run the following command to create a new Nuxt 3 project:


npx nuxi init nuxt3-app

This command creates a new directory named nuxt3-app with the initial Nuxt 3 project structure. Feel free to replace nuxt3-app with your preferred project name.

Step 2: Navigate to Your Project Directory

Change into your newly created project directory with:

cd nuxt3-app

Step 3: Install Dependencies

Now, install the project dependencies by running:


npm install

This command reads the package.json file in your project directory and installs the necessary packages.

Step 4: Run Your Nuxt 3 Project

With the dependencies installed, you're ready to launch your Nuxt 3 application. Start the development server with:


npm run dev

This command starts a local server. Once it's running, open your web browser and navigate to http://localhost:3000 to see your Nuxt 3 application in action.

Congratulations 🎉!
You've successfully set up and run your first Nuxt 3 project.

Exploring Nuxt 3 Features

Nuxt 3 comes packed with features that make web development seamless and efficient. Here are a few key features to explore:

File-based Routing:
Nuxt 3 automatically generates routes for your application based on the Vue files in the pages directory.

Fast Hot Module Replacement (HMR):
Enjoy instant feedback on your changes during development without full page reloads.

Composition API:
Utilize Vue 3's Composition API in your Nuxt 3 projects for better code organization and reuse.

Server-Side Rendering (SSR) and Static Site Generation (SSG):
Easily create pre-rendered pages or static websites for improved performance and SEO.

Next Steps

Now that you have your Nuxt 3 project running, the possibilities are endless. Here are some suggestions for what to do next:

Explore the Documentation:
Visit the official Nuxt 3 documentation to deepen your understanding of its features and capabilities.

Experiment with Components:
Start creating Vue components in the components directory and use them in your pages.

Learn About Nuxt Modules:
Nuxt modules extend your project's functionality. Check out modules like @nuxtjs/axios for making HTTP requests or @nuxtjs/auth-next for authentication.

Wrapping Up

Nuxt 3 simplifies Vue.js development by providing a robust framework packed with features to enhance your productivity and the performance of your applications. By following this guide, you've taken your first steps into the world of Nuxt 3. Continue experimenting, building, and learning as you unlock the full potential of this powerful framework.

Thanks 👋 for reading and supporting!

Mastering Node.js CLI: Best Practices and Tips

Boudy de Geer — Tue, 06 Feb 2024 08:39:26 +0000

This article is inspired by this awesome GitHub repository created by @lirantal, please go ahead and have a look it's worth.

lirantal / nodejs-cli-apps-best-practices

The largest Node.js CLI Apps best practices list ✨

Learn Node.js Secure Coding techniques and best practices from Liran Tal

Node.js CLI Apps Best Practices

A collection of curated best practices on how to build successful, empathic and user-friendly Node.js Command Line Interface (CLI) applications

Why this guide?

A bad CLI can easily discourage users from interacting with it. Building successful CLIs requires attention to detail and empathy for the user in order to create a good user experience. It is very easy to get wrong.

In this guide I have compiled a list of best practices across areas of focus which aim to optimize for an ideal user experience when interacting with a CLI application.

Features:

✅ 37 best practices for building successful Node.js CLI applications
✅ Read in a different language: 🇨🇳, 🇪🇸, or help translate to other languages. Suggest new languages.
🙏 Contributions are welcome

Why me?

Hi there, I'm Liran Tal and…

View on GitHub

Creating a command-line interface (CLI) in Node.js goes beyond basic functionality; it's about offering an intuitive, efficient, and user-friendly experience. Let’s explore the best practices to enhance your Node.js CLI applications, complete with examples to guide you along the way.

1. Respecting POSIX Arguments

POSIX-compliant argument syntax ensures your CLI aligns with familiar standards, reducing the learning curve for users.

// Using yargs for POSIX-compliant arguments parsing
const yargs = require('yargs/yargs');
const { argv } = yargs(process.argv.slice(2))
  .option('verbose', {
    alias: 'v',
    type: 'boolean',
    description: 'Run with verbose logging'
  });

This code snippet uses yargs, a Node.js package, to parse command-line arguments in a POSIX-compliant way, including support for short and long-form options. You could also use the popular commander defined as a complete node.js command-line interface.

2. Building Empathic CLIs

An empathic CLI anticipates user errors and guides them towards correct usage, enhancing user experience.

// Simple check for required arguments
if (!process.argv[2]) {
  console.log("Please provide the required argument.");
}

This example demonstrates basic input validation, ensuring users are prompted for necessary arguments.

3. Stateful Data Management

Remembering user preferences between sessions makes your CLI more intuitive and user-friendly.

// Using configstore for managing stateful data
const Configstore = require('configstore');
const config = new Configstore('my-cli-app');

// Saving a user preference
config.set('theme', 'dark');

// Retrieving the saved preference
const theme = config.get('theme');

Configstore is an excellent tool for handling persistent data across user sessions.

4. A Colorful CLI Experience

Colors can make your CLI more engaging and easier to navigate, but always provide options for colorless output.

// Using chalk for colored output
const chalk = require('chalk');
console.log(chalk.blue('This is a message in blue'));

Chalk is a popular choice for adding colors to CLI output while maintaining readability.

5. Enhancing Interactivity

Rich interactions like dropdowns or progress bars can significantly improve user experience.

// Using inquirer for interactive prompts
const inquirer = require('inquirer');

inquirer.prompt([
  {
    type: 'list',
    name: 'script',
    message: 'Which setup script do you want to run?',
    choices: ['Install', 'Configure', 'Update'],
  }
]).then(answers => {
  console.log(`Running ${answers.script} script...`);
});

Inquirer.js is a handy tool for adding interactive prompts to your CLI.

6. Utilizing Hyperlinks

Embedding hyperlinks in your CLI's output can provide users with quick access to resources and documentation.

// Printing a clickable URL in the terminal
console.log('Visit our documentation: https://docs.example.com');

Most modern terminals will automatically detect and make URLs clickable.

7. Zero Configuration for Initial Setup

A CLI that requires minimal setup enhances user satisfaction by reducing initial friction.

Detecting environment variables can be a part of zero-configuration design. No specific code example here, but the idea is to use existing system settings or sensible defaults whenever possible.

8. Respecting POSIX Signals

Proper handling of POSIX signals like SIGINT ensures your CLI terminates gracefully and behaves predictably.

// Graceful shutdown on SIGINT (Ctrl+C)
process.on('SIGINT', () => {
  console.log('Process interrupted. Exiting gracefully.');
  process.exit(0);
});

Handling SIGINT allows your CLI to clean up resources or save state before exiting.

Developing a Node.js CLI isn't just about getting the job done; it's about crafting an experience that users find intuitive and delightful. By following these best practices, from respecting POSIX standards to handling stateful data and enhancing interactivity, you can create a CLI that not only performs well but also resonates with its users. Remember, the key to a great CLI is a balance between functionality, usability, and a touch of creativity!