Forem: Alberto Barrago

I Built My Own Diagramming Tool

Alberto Barrago — Thu, 09 Apr 2026 14:57:26 +0000

Hey! I’ve been working on Markasso, a lightweight drawing and diagramming tool. Built entirely from scratch with vanilla JS and Canvas 2D API. No frameworks, no libraries, nothing.

Why I built it: In this AI era where you can generate anything in seconds, I wanted to actually build something myself from the ground up. Understand (or try to do it) every line, every pixel, every math formula behind it.

My grandmother was a math teacher so I guess the stubbornness runs in the family, but I’ll be honest, Claude helped me a lot when the geometry got tricky and Lorenzo Cataldi with the UI.

Everything is hand-rolled: pure Canvas API (no SVG), a Redux-like state management with immutable state and action-based updates, hit detection, bounding boxes, transform handles, undo/redo via action stack. Single user, runs entirely in the browser.

It’s also packed with little things I cared about: full keyboard shortcuts, multi-language support, a magnetic grid for snapping, and custom format export. I wanted it to feel like a real tool, not just a tech demo.

The hardest part was making resize handles feel natural when you’re doing all the geometry yourself.
Once you try building this stuff from scratch you really start to appreciate what the Excalidraw team has done.

Make a trip ^^

Source Code

Would love to hear your feedback, especially on UX and what features you’d want to see next!

Fix: Eliminating Double Async Validation in TanStack Form & Zod

Alberto Barrago — Tue, 17 Feb 2026 18:10:16 +0000

A practical pattern to prevent duplicate API calls and race conditions
in complex React forms.

When building production-grade forms with TanStack Form and Zod,
especially in flows involving side effects (e.g., OTP generation,
user verification), you may encounter an elusive bug:

⚠️ Async validation running twice on submit

This can lead to duplicated API calls, inconsistent state, and poor user
experience.

In this article, we explore: - Why this happens - How to fix it
reliably - How to harden your form logic for real-world scale

🚨 The Problem: Double Async Execution

A known issue in TanStack Issue #1431 causes async
validation (superRefine) to execute multiple times during submission.

Typical Setup

const form = useForm({
  defaultValues: { ... },
  validators: {
    onChange: myZodSchema, // async superRefine
  },
  onSubmit: async ({ value }) => {
    await sendOtp(value); // ❌ may be called twice
  }
});

Why It's Dangerous

In flows like OTP authentication: - Multiple requests generate
different codes - First code becomes invalid - Users get stuck

👉 This is not just inefficiency --- it's a critical UX bug

🧠 Root Cause

TanStack Form may trigger validation multiple times internally
superRefine contains side effects
Validation ≠ Pure function anymore

👉 This breaks the expectation that validation is idempotent

✅ The Solution: Take Back Control

We fix the issue with 3 architectural decisions:

1. Manual Validation with `safeParseAsync`

Avoid relying on automatic validation during submission.

const result = await myZodSchema.safeParseAsync(form.state.values);

✔ Prevents double execution
✔ Gives full control over validation lifecycle

2. Prevent Re-entrancy with `useRef`

React state is not always fast enough to block rapid interactions.

Use a low-level semaphore:

const isSubmittingRef = useRef(false);

3. Decouple Side Effects

Never trigger API calls inside validation.

👉 Validation must remain pure
👉 Side effects go inside controlled submit flow

🧩 Full Implementation

const isSubmittingRef = useRef(false);

const handleSubmit = async () => {
  if (isSubmittingRef.current) return;

  isSubmittingRef.current = true;

  try {
    // 1. Manual validation
    const result = await myZodSchema.safeParseAsync(form.state.values);

    if (!result.success) {
      // map errors if needed
      return;
    }

    // 2. Execute side effect ONCE
    await triggerOtpRequest(result.data);

  } finally {
    isSubmittingRef.current = false;
  }
};

🌐 Network Layer Optimization

During testing, another issue emerged: 👉 unwanted re-fetching
disrupting UX

Fix your QueryClient config:

const queryClient = new QueryClient({
  defaultOptions: {
    queries: {
      staleTime: 5 * 60 * 1000,
      refetchOnWindowFocus: false,
    },
  },
});

Why it matters

Users switch tabs to check OTP
Returning triggers refetch
UI state resets unexpectedly

👉 Disable it for critical flows

🏗️ Production Insights

From a real-world system serving high traffic:

Small validation bugs can scale into massive API waste
Race conditions are often invisible locally
Libraries are not always safe for side-effect-heavy flows

👉 Always design defensively

🔑 Key Takeaways

Validation must be pure
Avoid side effects inside superRefine
Control execution manually
Use safeParseAsync
Prevent race conditions
Use useRef as a semaphore
Tune network behavior
Disable refetchOnWindowFocus when needed

💬 Final Thoughts

If your validation triggers APIs, you are no longer just validating
you are orchestrating stateful workflows.

👉 Treat it like backend logic, not just form validation.

🚀 Discussion

Have you experienced similar issues with async validation or race
conditions in React forms?

Let's discuss 👇

RefAIne: Transform Casual Prompts into Expert-Level AI Instructions

Alberto Barrago — Mon, 05 Jan 2026 22:42:48 +0000

A free, open-source FastAPI microservice that converts simple prompts into detailed, production-ready AI instructions. Supports multiple LLM providers including Claude, OpenAI, Ollama, and Groq.

The Problem

Getting AI assistants to understand exactly what you need often requires multiple iterations. When you ask to "create a REST API," you might get a basic example when you actually need authentication, error handling, validation, and production-ready code.

This gap between brief prompts and detailed requirements costs developers significant time in refinement cycles.

The Solution

RefAIne is a FastAPI microservice (approximately 145 lines) that transforms casual prompts into comprehensive engineering instructions.

Example Input: "make a function to sort a list"

Example Output:

Create a Python function that sorts a list with the following requirements:

Function signature: Accept a list of comparable elements as input

Return a new sorted list (do not modify the original)

Use Python's built-in sorting (efficient O(n log n) Timsort)

Add type hints and docstrings with examples

Include error handling for None or non-list inputs

Handle edge cases: empty list, single element, already sorted

Make it generic to work with any comparable types

Provide clean, PEP 8 compliant code with tests.

RefAIne automatically adds technical context, specificity, best practices, and edge case considerations.

Key Features

Free Testing Options

Test locally with Ollama at no cost before using paid APIs. No credit card or API key required for initial testing.

Multiple Provider Support

Switch between LLM providers using a single environment variable:

Ollama (free, local, private)
Groq (free tier available)
Anthropic Claude (paid)
OpenAI (paid)
Any OpenAI-compatible API

Production Ready

Includes Docker configuration, comprehensive documentation, and environment-based configuration.

Focused Design

Single-purpose service with one endpoint and minimal dependencies.

About the Project

RefAIne was created by Alberto Barrago to automate the prompt refinement process. The project is open-source under the MIT license, allowing use in commercial projects without restrictions.

Supporting Development

RefAIne is free to use and will remain so. However, maintaining open-source software requires ongoing investment:

Server costs for testing and demonstrations
API credits for development across multiple providers
Time for bug fixes, features, and support
Documentation and example creation

If RefAIne has been useful in your work, consider supporting the project:

Star the repository: github.com/AlbertoBarrago/RefAIne
Contribute financially via GitHub Sponsors or donation platforms
Share the project with other developers
Report issues or contribute code improvements

Financial support helps maintain active development, add new provider integrations, improve refinement quality, and respond to community needs.

Quick Start

# Clone repository
git clone https://github.com/AlbertoBarrago/RefAIne.git
cd RefAIne

# Install and configure Ollama (for free local testing)
curl -fsSL https://ollama.com/install.sh | sh
ollama pull llama3.1

# Set up environment
cat > .env << EOF
LLM_PROVIDER=openai
OPENAI_BASE_URL=http://localhost:11434/v1
OPENAI_API_KEY=ollama
OPENAI_MODEL=llama3.1
EOF

# Install and run
uv pip install -r pyproject.toml
uvicorn main:app --reload

# Test the endpoint
curl -X POST http://localhost:8000/refine \
  -H "Content-Type: application/json" \
  -d '{"prompt": "create a REST API"}'

Interactive API documentation is available at http://localhost:8000/docs.

Resources

GitHub Repository: github.com/AlbertoBarrago/RefAIne
Issue Tracker: Report bugs or request features
Documentation: Included in repository README

Contributions and feedback are welcome.

WIR - What Is Running: A CLI Tool in C to Inspect Processes and Ports

Alberto Barrago — Tue, 30 Dec 2025 20:28:59 +0000

I recently released wir (What Is Running), a command-line tool written in C to inspect what's running on specific ports and get detailed process information. A project born from a practical need that turned into an opportunity to explore system programming in C.

The Problem

How many times have you had a port occupied without knowing which process is using it? Or needed to trace a process hierarchy to understand who spawned what? We usually resort to combinations of lsof, netstat, and ps, but why not have everything in a single command?

The Solution

wir is a cross-platform tool (macOS and Linux) that allows you to:

Discover which process is using a specific port
Get detailed information about a PID
Visualize the complete ancestry tree of a process
List all running processes
View a process's environment variables
Output in normal, short, JSON, or tree format
Receive security warnings for potentially risky configurations

Practical Examples

# Who's using port 8080?
wir --port 8080

# Info about a specific process
wir --pid 1234

# Show the process ancestry tree
wir --pid 1234 --tree

# JSON output for scripting
wir --port 3000 --json

# List all processes (short format)
wir --all --short

# Security warnings only
wir --port 8080 --warnings

The Architecture

The project is structured in a modular way:

Platform abstraction layer: handles differences between Linux (/proc parsing) and macOS (libproc and sysctl)
Output formatting: supports multiple display modes without duplicating logic
Consistent error handling: every allocation is checked, every resource is freed
Strict memory management: no leaks, no undefined behavior

What I Learned

Writing wir was an excellent opportunity to practice fundamental concepts:

System programming: interfacing with /proc, system calls, process management
Cross-platform development: conditional compilation and different APIs for each OS
Memory safety in C: manual memory management without a garbage collector
Build systems: Makefile with automatic platform detection
API design: clean and composable interface

I Don't Memorize Commands

As my approach goes: I'm not interested in memorizing the exact lsof or netstat commands. I prefer understanding the underlying architecture and building tools that solve the problem more elegantly. wir isn't just a wrapper, it's an abstraction that hides the complexity of OS differences.

The Future

The project is open to extensions:

UDP port support
Advanced process filtering
Support for other OSes (BSD, etc.)
Performance optimizations
Additional output formats

Try It Out

wir

It's a learning project, so feel free to experiment and extend it. Building system tools in C is a great way to understand what's really happening under the hood.

# Build and install
brew tap AlbertoBarrago/tap
brew install wir

# Start using it
wir --port 3000

Neovim + COQ + Mason + LSP: Mini Guide

Alberto Barrago — Mon, 17 Nov 2025 22:16:29 +0000

This guide explains how to properly set up COQ.nvim autocomplete
with Mason and LSP servers in Neovim. It includes the most
common pitfalls and a working configuration.

🔧 1. Install Required Plugins

Make sure you have:

ms-jpq/coq_nvim
ms-jpq/coq.artifacts (optional, extra completions)
williamboman/mason.nvim
williamboman/mason-lspconfig.nvim
neovim/nvim-lspconfig

Example (lazy.nvim):

{
  "ms-jpq/coq_nvim",
  branch = "coq",
},
{
  "ms-jpq/coq.artifacts",
  branch = "artifacts",
},
{
  "williamboman/mason.nvim",
  config = true,
},
{
  "williamboman/mason-lspconfig.nvim",
  dependencies = { "neovim/nvim-lspconfig" },
},

⚡ 2. Enable COQ Auto-Start

COQ does not start automatically unless configured.

vim.g.coq_settings = { auto_start = 'shut-up' }

Alternatively, use manually later:

:COQnow

🧠 3. Correct Working LSP + COQ Setup

require("mason").setup()

local coq = require("coq")

require("mason-lspconfig").setup({
    ensure_installed = { "pyright", "jdtls", "dockerls", "elixirls", "ts_ls" },
    automatic_installation = true,

    handlers = {
        function(server_name)
            require("lspconfig")[server_name].setup(
                coq.lsp_ensure_capabilities({})
            )
        end,

        ["elixirls"] = function()
            require("lspconfig").elixirls.setup(
                coq.lsp_ensure_capabilities({
                    settings = {
                        flags = {
                            debounce_text_changes = 150,
                        },
                        elixirLS = {
                            dialyzerEnabled = false,
                            fetchDeps = false,
                        }
                    }
                })
            )
        end,
    },
})

❗ 4. What Not To Do

❌ Do NOT use omnifunc with COQ

autocmd FileType markdown setlocal omnifunc=coq#complete

Remove this. COQ does not use omnifunc.

🧪 5. Verification Steps

✔ Check if LSPs are connected:

:LspInfo

✔ Check COQ status:

:COQnow

✔ Test autocomplete

Open a file and type --- completion should appear.

🐛 6. Common Issues & Fixes

❗ Autocomplete doesn't show up

COQ not started → :COQnow
LSP not attached → :LspInfo
Missing capabilities → use coq.lsp_ensure_capabilities()
Remove delayed init like vim.defer_fn

❗ Markdown has no completion

Install a Markdown LSP:

ensure_installed = { "marksman", ... }

🎉 Done!

You now have a clean Neovim setup using COQ + Mason + LSP.

Level Up Your Terminal Workflow: Helix + Yazi

Alberto Barrago — Tue, 04 Nov 2025 14:35:00 +0000

If you're looking for a modern, efficient terminal-based development setup, let me introduce you to a powerful combination: Helix (a post-modern text editor) and Yazi (a blazingly fast terminal file manager).

Why This Combo?

Helix is a Kakoune-inspired editor with built-in LSP support, multiple cursors, and tree-sitter integration. It's fast, has sane defaults, and no plugin configuration needed.

Yazi is a terminal file manager written in Rust that's incredibly fast and intuitive. Think of it as a visual way to navigate your projects before diving into code.

Together, they create a lightweight alternative to heavy IDEs while keeping you productive.

Moving Away from JetBrains

I've been reflecting on my development tools lately, and I'm not particularly proud of relying on JetBrains products anymore. Their direction seems increasingly Microsoft-addicted - just look at Rider becoming primarily a .NET IDE focused on game development, while languages like Erlang and other niche but important ecosystems are left out of the scene.

The bloat, the subscription model, and the narrowing focus pushed me to explore lighter, more universal alternatives. That's how I discovered this setup.

Setup

1. Install Both Tools

# macOS
brew install helix yazi

# Linux (check your distro's package manager)
# Arch
sudo pacman -S helix yazi

# Other distros - check helix-editor.com and yazi-rs.github.io

2. Configure Yazi to Open Files in Helix

Create ~/.config/yazi/yazi.toml:

[opener]
edit = [
  { run = 'hx "$@"', block = true },
]

3. Customize Your Helix Theme (Optional)

Create a custom dark theme at ~/.config/helix/themes/my-theme.toml:

"ui.background" = { bg = "#1e1e1e" }
"ui.text" = { fg = "#d4d4d4" }
"ui.selection" = { bg = "#264f78" }
"ui.cursor" = { fg = "#1e1e1e", bg = "#aeafad" }
"ui.linenr" = { fg = "#858585" }
"ui.linenr.selected" = { fg = "#c6c6c6" }

"comment" = { fg = "#6a9955", modifiers = ["italic"] }
"keyword" = { fg = "#569cd6" }
"function" = { fg = "#dcdcaa" }
"string" = { fg = "#ce9178" }
"variable" = { fg = "#9cdcfe" }
"type" = { fg = "#4ec9b0" }

Then set it in ~/.config/helix/config.toml:

theme = "my-theme"

Workflow

Navigate with Yazi:

   cd ~/your-project
   yazi

Browse your project structure using arrow keys or hjkl
Press Enter on any file to open it in Helix
Edit in Helix with LSP support, syntax highlighting, and multiple cursors
Save and exit (Ctrl+s, then :q) to return to Yazi
Repeat - navigate to next file

Helix Quick Tips

Space + f - Fuzzy file finder
Space + b - Buffer (open files) picker
Space + / - Global search in project
mf - Select function, md - select around
Multiple cursors: C to add cursor, Alt+C to remove

Why Not Just Use Helix's Built-in Picker?

You absolutely can! Helix has excellent fuzzy finding (Space + f). But Yazi gives you:

Visual tree structure
Quick file operations (copy, move, rename)
Image previews
Directory sizes
A complementary tool for different tasks

Conclusion

This setup gives you the speed and simplicity of terminal tools with the power of modern editing features. No Electron bloat, no complex plugin configurations - just fast, efficient coding.

Give it a try and let me know what you think!

Resources:

Introducing RSS Reader: A Modern Native RSS Client for macOS

Alberto Barrago — Mon, 08 Sep 2025 12:54:11 +0000

I'm excited to share my latest creation: RSS Reader, a sleek and modern RSS client built specifically for macOS using Swift. This application brings back the joy of RSS feeds with a fluid, optimized user experience designed specifically for the Apple ecosystem.

What Makes It Special

RSS Reader is built from the ground up as a native macOS application, ensuring smooth performance and seamless integration with your Mac. The app features a clean, intuitive interface that makes managing and reading your favorite RSS feeds effortless.

Key highlights include:

Native Swift Development: Built specifically for macOS, ensuring optimal performance and system integration
Modern Architecture: Clean, maintainable code with proper separation of concerns
User-Friendly Interface: Intuitive design that focuses on readability and ease of use
Efficient Parsing: Robust RSS parsing with proper error handling and data persistence

Technical Details

The application uses a sophisticated parsing system with XMLParser and delegate patterns, ensuring reliable feed processing. It includes proper data persistence through ModelContext and supports both individual feed updates and bulk refresh operations.

Get Started

Download: RSS Reader on GitHub

The repository includes complete build instructions - simply clone, open in Xcode, and run. Whether you're using the simulator or a physical device, getting started is straightforward.

Community Discussion: Join the conversation about RSS Reader on Reddit where I've shared more details about the development process and gathered feedback from the macOS community.

Building and Running

Requirements are minimal - just macOS with Xcode installed. The project includes detailed setup instructions and a comprehensive RUN.md file to get you started quickly.

RSS Reader represents my commitment to creating quality, native applications for the Apple ecosystem. Give it a try and rediscover the power of RSS feeds with a modern, polished interface.

Built with Swift for macOS | Open Source | Community Driven

The Chrome Cookbook: Recipes for a Better Workflow

Alberto Barrago — Thu, 28 Aug 2025 07:39:29 +0000

Want to become a Chrome power user? Skip the long-winded articles. This is a cookbook of simple, effective "recipes" to make your browsing and development more efficient. Just a few lines per tip—copy, paste, and master.

The Search Chef's Pantry

Your address bar is a powerful kitchen tool. Learn these basic ingredients to cook up the perfect search query every time.

Exact Phrase: To find the exact phrase, wrap it in quotes.

"devops engineer salary"

Exclusion: To remove a keyword, use a minus sign.

jaguar -car (finds the animal) or hello -ai (without ai preview)

Site-Specific Search: To search only one website, use site:.

site:dev.to "containerization"

File Type Search: To find a specific file type, use filetype:.

react native cheatsheet filetype:pdf

Date Range: To find results within a specific time frame, use before: or after:.

AI research after:2024-01-01

Title Search: To find a keyword only in the page title, use intitle:.

intitle:"Fullstack developer" roadmap

Final Dish

These recipes are just a starting point. Mix and match them to create your own unique workflow. As a fellow developer, I find these tips help me save precious minutes from my daily tasks.

The New Era of Color on the Web: Understanding OKLCH

Alberto Barrago — Mon, 25 Aug 2025 13:29:27 +0000

The way we define and use color on the web is evolving. While older models like sRGB have been the standard, a new, more intuitive system is gaining traction: OKLCH. This article will explore what OKLCH is, its benefits, and how you can start using it today.

What is OKLCH?
OKLCH is a modern color model that is perceptually uniform. This means it's designed to align more accurately with how the human eye perceives color. Unlike sRGB, which can behave unpredictably, OKLCH gives you a more reliable way to work with colors. It's composed of three key values:

L (Lightness): How light or dark a color is.
C (Chroma): The intensity or vividness of a color.
H (Hue): The shade of the color (e.g., red, blue, green).

This structure makes it incredibly simple to create harmonious color palettes and gradients. For example, by keeping the "L" and "C" values consistent, you can generate a series of shades that maintain the same perceived brightness, avoiding the "hue drift" that can happen with other models.

The Impact on Visualization and Compatibility
The move to OKLCH is part of a larger shift in the web's visualization era, where modern displays support a wider range of colors, or "gamut," than the traditional sRGB standard. OKLCH can access these wider color spaces, allowing designers to create more vibrant and vivid designs.

A crucial aspect of this transition is ensuring compatibility. While most modern browsers support OKLCH, older browsers do not. This is where CSS's @supports rule comes in. It allows you to provide a fallback for older browsers, ensuring your design looks good everywhere.

Here is an example of how to implement this using a simple gray color palette, as you requested:

@layer base {
  :root {
    /* sRGB hex */
    --color-gray-100: #fcfcfc;
    --color-gray-200: #fafafa;
    --color-gray-300: #f4f4f4;

    @supports (color: oklch(0 0 0)) {
      /* OKLCH */
      --color-gray-100: oklch(0.991 0 0);
      --color-gray-200: oklch(0.982 0 0);
      --color-gray-300: oklch(0.955 0 0);
    }
  }
}

This code snippet first defines the gray colors using the standard sRGB hex codes. Then, within the @supports block, it redefines those colors using the OKLCH values. Browsers that understand oklch will use the new values, while older ones will fall back to the hex codes, ensuring a consistent user experience.

You can learn more about this topic and see a practical tool for generating color palettes at the original source: jakub.kr

Proctoring – My Latest Side Project to Catch Cheaters (Gently)

Alberto Barrago — Tue, 22 Jul 2025 14:26:45 +0000

Hey everyone!
I just published Proctoring, a side project I’ve been working on in my free time. It's a lightweight browser-based proctoring system built with PHP and JavaScript.

The goal? Help detect suspicious behavior during online exams—without needing a big AI team or a million-dollar budget.

It can track things like:

If the student is looking away from the screen too much
If another person appears on camera
If a phone is in view
If there are unexpected sounds or voices in the background

It's not perfect (yet), but it’s a start—and it was a great excuse to dive deeper into browser media APIs, video analysis, and some clever tricks to sync everything in real-time.

Doc-Piloot: Because Bad READMEs Are a Crime Against Humanity

Alberto Barrago — Fri, 04 Jul 2025 13:56:58 +0000

Or: How I Got Tired of Seeing "TODO: Add README" on Every Repo

The Problem That Broke My Soul

Picture this: You're browsing GitHub, you find what looks like an amazing project, you click on the repo and... BAM. Either there's no README at all, or worse, there's a README that just says "My awesome project" with zero context about what it actually does.

After years of encountering these digital wastelands disguised as documentation, I finally snapped. I couldn't take it anymore. The developer in me screamed "THERE HAS TO BE A BETTER WAY!"

So I built one.

Meet Doc-Piloot (Yeah, the Name's a Story)

I wanted to call it "Doc-Pilot" because, you know, it's like having a copilot for your documentation. Makes sense, right? Wrong. Turns out that name was already taken. So here we are with "Doc-Piloot" which honestly sounds even cooler because it's got that mysterious European flair.

Doc-Piloot is your AI copilot for project documentation that automatically generates comprehensive README files for GitHub repositories. It's like having a technical writer on your team who never sleeps, never complains, and actually understands your code.

How This Magic Works

The beauty of Doc-Piloot is in its simplicity. You literally just:

Install the GitHub App on your repository
Add --doc to your commit message when you push to main
Watch the magic happen

That's it. No complex configuration, no lengthy setup processes, no sacrificing your firstborn to the documentation gods.

When you push a commit with --doc in the message, Doc-Piloot springs into action:

It analyzes your entire repository structure
Detects programming languages and frameworks
Understands your project's purpose and functionality
Generates a professional README.md file
Creates a pull request on a new branch called update-readme

If the update-readme branch doesn't exist, it creates one. If it does exist, it updates it. It's like having a very organized, very efficient documentation assistant.

The Tech Stack (For the Nerds)

Doc-Piloot is built with some seriously cool technology:

TypeScript Bleah... just for audience
Google Gemini AI for the brain power
GitHub API via Octokit for seamless integration
Smart analysis algorithms that actually understand your code

The AI doesn't just generate generic fluff. It actually looks at your code, understands the structure, identifies the main technologies you're using, and creates documentation that makes sense.

Why This Matters More Than You Think

Good documentation isn't just about being nice to other developers (though that's important too). It's about:

Reducing onboarding time for new team members
Making your projects more discoverable and trustworthy
Saving your future self from the "what does this code do?" confusion
Actually shipping projects instead of procrastinating on documentation

I've seen too many brilliant projects die in obscurity because nobody could figure out how to use them. Don't let your code become digital archaeology.

Try It Out (Seriously, Do It)

If you're tired of staring at empty README files, or if you're one of those people who's been putting off writing documentation for months, give Doc-Piloot a shot.

The worst that can happen is you get a professionally written README for free. The best that can happen is you never have to write another README from scratch again.

Because life's too short for bad documentation, and your projects deserve better than "TODO: Add README."

Repo

What's your biggest documentation pain point? Have you tried any other automated documentation tools? Let me know in the comments - I'm always looking for ways to make Doc-Piloot even better.

P.S. If you're wondering why I'm so passionate about this, it's because I've spent way too many hours trying to figure out how to use undocumented projects. Consider this my gift to future developers who just want to understand what your code does without having to reverse engineer it.

The Mirror We Built

Alberto Barrago — Wed, 18 Jun 2025 23:12:00 +0000

Let me be clear: intelligence is not in the machine.

IMHO, what we’re seeing today is just a reflection of us. Of our choices, our questions, our awareness, or sometimes, our laziness.

We used to ask each other things in bars. Then we trusted the television. Now many ask search boxes or chat interfaces questions like:

Can I find love?

Can you make me a startup with a button that prints money?

Should I invest in crypto now?

If you don’t know what you’re really asking, and you expect a shortcut to something you don’t understand, who’s responsible?

The machine??

Or the person using it?

Tools Don't Make You Smarter

The tool is innocent.

Fire is a tool. So is money. So is code.

And so is this thing everyone keeps calling “intelligent.”

But power doesn’t mean wisdom. If you can’t handle the tool, if you use it like a crutch or a trick, it won’t elevate you. It’ll just expose you.

What you get depends on what you give.

Raise Your Standards

If you ask something without thought, you’ll get something empty. If you don’t reflect, don’t study, don’t go deep... don’t expect magic.

This isn’t about jobs or automation. The real danger isn’t being replaced.

It’s forgetting how to think.

A Question Worth Asking

What do you want from the tools you use?

Are you building? Reflecting? Creating something real?

Let’s talk about it. The tool is in our hands. What we do with it, that’s the only part that matters.

Drop your thoughts. Let’s keep this human ♥️

Forem: Alberto Barrago

I Built My Own Diagramming Tool

Fix: Eliminating Double Async Validation in TanStack Form & Zod

🚨 The Problem: Double Async Execution

Typical Setup

Why It's Dangerous

🧠 Root Cause

✅ The Solution: Take Back Control

1. Manual Validation with safeParseAsync

2. Prevent Re-entrancy with useRef

3. Decouple Side Effects

🧩 Full Implementation

🌐 Network Layer Optimization

Fix your QueryClient config:

Why it matters

🏗️ Production Insights

🔑 Key Takeaways

💬 Final Thoughts

🚀 Discussion

RefAIne: Transform Casual Prompts into Expert-Level AI Instructions

The Problem

The Solution

Key Features

Free Testing Options

Multiple Provider Support

Production Ready

Focused Design

About the Project

Supporting Development

Quick Start

Resources

WIR - What Is Running: A CLI Tool in C to Inspect Processes and Ports

The Problem

The Solution

Practical Examples

The Architecture

What I Learned

I Don't Memorize Commands

The Future

Try It Out

Neovim + COQ + Mason + LSP: Mini Guide

🔧 1. Install Required Plugins

⚡ 2. Enable COQ Auto-Start

🧠 3. Correct Working LSP + COQ Setup

❗ 4. What Not To Do

❌ Do NOT use omnifunc with COQ

🧪 5. Verification Steps

✔ Check if LSPs are connected:

✔ Check COQ status:

✔ Test autocomplete

🐛 6. Common Issues & Fixes

❗ Autocomplete doesn't show up

❗ Markdown has no completion

🎉 Done!

Level Up Your Terminal Workflow: Helix + Yazi

Why This Combo?

Moving Away from JetBrains

Setup

1. Install Both Tools

2. Configure Yazi to Open Files in Helix

3. Customize Your Helix Theme (Optional)

Workflow

Helix Quick Tips

Why Not Just Use Helix's Built-in Picker?

Conclusion

Introducing RSS Reader: A Modern Native RSS Client for macOS

What Makes It Special

Technical Details

Get Started

Building and Running

The Chrome Cookbook: Recipes for a Better Workflow

The New Era of Color on the Web: Understanding OKLCH

Proctoring – My Latest Side Project to Catch Cheaters (Gently)

Doc-Piloot: Because Bad READMEs Are a Crime Against Humanity

The Problem That Broke My Soul

Meet Doc-Piloot (Yeah, the Name's a Story)

How This Magic Works

The Tech Stack (For the Nerds)

Why This Matters More Than You Think

Try It Out (Seriously, Do It)

1. Manual Validation with `safeParseAsync`

2. Prevent Re-entrancy with `useRef`