Forem: DiegoDev

Stop Asking AI to Write Your Backend Code

DiegoDev — Tue, 03 Mar 2026 00:35:23 +0000

Every time you ask an AI to generate a backend, something slightly annoying happens: it writes 200 lines of TypeScript, picks its own folder structure, names things its own way, and somewhere in the middle it hallucinates an import that doesn't exist.

You then spend 20 minutes fixing what should've taken 2.

The thing is, this isn't really the AI's fault. You asked it to do too much.

What Terraform figured out

Think about how Terraform works.

When you want to provision infrastructure, you don't ask an AI to write raw AWS API calls. That's complex, verbose, and easy to get wrong. Instead, you describe what you want:

resource "aws_s3_bucket" "my_bucket" {
  bucket = "my-app-storage"
  acl    = "private"
}

And Terraform handles the rest. The AI only needs to learn a small, constrained language. The hard work is handled by the system.

The same idea applies to backend generation. We've just been too slow to notice.

What we're doing wrong today

The current AI-for-backend workflow looks like this:

User → "Build me a REST API for users with JWT and Supabase" → AI → 200 lines of code → you fix the mess

The AI is generating the implementation. That's the wrong layer.

It burns tokens on boilerplate. It makes architectural decisions it shouldn't. And every project ends up slightly different because the AI is improvising every single time.

The better way: a DSL

What if instead, the AI's only job was to write something like this?

config {
  db:   supabase
  auth: jwt
}

table "users" {
  id:         uuid      @primary
  email:      string    @unique
  name:       string
  created_at: timestamp @default(now)
}

resource "users" {
  table: users
  endpoints {
    GET    /users
    POST   /users
    GET    /users/:id
    PUT    /users/:id
    DELETE /users/:id
  }
}

And your system generates the actual TypeScript, the router, the database client, the handlers — everything.

The AI doesn't write code. The AI speaks your language, and your language generates code.

Why this matters

Consistency. Every project generated from the same DSL looks the same. Same folder structure, same naming conventions, same patterns. No more "why did it do it this way this time?".

Token efficiency. 10 lines of DSL vs 200 lines of TypeScript. The AI's job just got 20x cheaper.

Predictability. The AI can't hallucinate an import that doesn't exist in your DSL. The language is closed and constrained. If the AI writes valid DSL, the output is valid code. Period.

You own the generator. Want to switch from Express to Hono? Update the generator once. Every project benefits automatically.

Basalt: an early answer to this problem

This is exactly what we're building with Basalt.

Basalt is an open source CLI written in Go. You give it a .bs file describing your backend — tables, endpoints, auth — and it generates all the TypeScript you need, ready to run.

Ask any AI to read the Basalt spec and write your main.bs
→ basalt generate
→ cd generated && npm install && npm run dev

That said — Basalt is just getting started. We're at v0.1.0 and the generator is still pretty basic: Express + TypeScript + Supabase, same template structure for every project. It doesn't do magic yet.

But the foundation is there, it works, and the direction is clear. Upcoming versions will bring more frameworks, more databases, custom templates, and eventually a basalt ai command that takes plain English and generates the .bs for you.

→ github.com/DiegoDev2/Basalt

The bigger picture

We're at an interesting moment with AI and code generation. The first instinct was "just let the AI write everything." But the more mature approach is starting to emerge: design constrained languages that AI can speak fluently, then build systems that compile those languages into real artifacts.

Terraform did this for infrastructure. Prisma did this for database schemas. OpenAPI did this for API contracts.

Backend generation is next — and the pieces are already there. We just need to stop handing the AI a blank canvas and start giving it a grammar.

What do you think? Is this a pattern you'd use? Drop a comment — would love to hear how others are thinking about this.

Introducing cmdr.ai: An AI-Powered Copilot for Your Terminal

DiegoDev — Thu, 10 Jul 2025 18:28:16 +0000

Introducing cmdr.ai: An AI-Powered Copilot for Your Terminal

Terminal errors are a daily reality for developers, DevOps engineers, and power users. Diagnosing and resolving these errors often means context switching, searching online, and losing valuable time.

cmdr.ai aims to streamline this process by providing instant, AI-driven suggestions directly in your terminal.

What is cmdr.ai?

cmdr.ai is an open-source command-line tool that integrates seamlessly with your shell (Zsh, Bash) to detect failed commands, analyze errors using state-of-the-art AI models (OpenAI, OpenRouter, Ollama, and more), and present concise, actionable solutions—without interrupting your workflow.

Key features:

Automatic error detection: No need to wrap commands or change your habits.
AI-powered suggestions: Leverages GPT and other models to provide practical fixes.
Persistent logging: Maintains a history of failed commands and AI suggestions in ~/.cmdr/.
Multi-provider support: Compatible with OpenAI, OpenRouter, Ollama, and extensible to others.
Flexible configuration: Supports both .cmdrconfig files and environment variables.
Professional terminal output: Clear, color-coded suggestions and a loading indicator.
Open source: MIT licensed and open to contributions.

Motivation

In modern development environments, efficiency and rapid problem-solving are essential.

cmdr.ai was created to:

Reduce the time spent diagnosing terminal errors
Provide immediate, context-aware solutions
Integrate naturally into existing developer workflows
Support a wide range of AI providers and configurations

Contributing

Contributions, feedback, and feature requests are welcome.

Visit the repository: https://github.com/DiegoDev2/cmdr.ai

Package manager on go(available in a few days.)

DiegoDev — Sat, 19 Oct 2024 07:23:48 +0000

https://github.com/DiegoDev2/Fleet

Introducing Fleet: A Simple Yet Powerful Package Manager for Developers 🚀

As developers, we often spend a lot of time setting up environments and installing different tools. I created Fleet to make this process easier and more efficient.

What is Fleet?

Fleet is a simple, lightweight package manager designed to help you install and manage development tools quickly and without hassle. Instead of juggling multiple package managers or manually downloading tools, Fleet handles everything with a single command.

Why You Should Use Fleet

Fleet is perfect for developers who:

Regularly set up new environments.
Work across multiple languages or tech stacks.
Want a faster, unified experience for tool management.