DEV Community: Luis Fernando Richter

I Built Cat Guardian for My Seven Cats 🐾

Luis Fernando Richter — Mon, 17 Aug 2026 14:45:48 +0000

This is a submission for Weekend Challenge: Dog Days Edition

🐾 Cat Guardian — Protect. Identify. Find.

I live with seven cats: Kiara, Golia, Meias, Vaquinha, Tigrinha, Peluda, and Gamora. They all have different personalities, different appearances, and different routines.

And, like many pet owners, there is one thing that has always worried me: What if one of them gets lost?

That question became the starting point for Cat Guardian.

What I Built

Cat Guardian is a privacy-first digital safety passport for cats.

The idea is simple: give each cat a digital identity containing the information that could actually help if they ever go missing.

The platform provides:

🐈 Digital identity for each cat
🩺 Health records and vaccination tracking
🧠 AI-assisted visual identification
🏷️ Dynamic QR collar tags
🚨 Lost Mode
📱 Public rescue passport
🔐 Privacy-preserving contact between finder and owner
🌎 English and Brazilian Portuguese localization

The problem

When a pet goes missing, useful information is often scattered across photos, veterinary records, paper documents, and the owner's memory.

Traditional collar tags can also expose personal information such as phone numbers or addresses. I wanted a different approach.

The QR code attached to the collar doesn't expose the owner's contact information. Instead, when someone finds the cat, they can scan the QR code and access a public rescue profile.

If the owner has activated Lost Mode, the finder can submit a sighting. The owner is then notified through a secure backend relay.

Owner
  │
  ▼
Cat Guardian
  │
  ├── Digital Identity
  ├── Health Records
  ├── AI Profile
  └── QR Collar Tag
          │
          ▼
      Lost Mode
          │
          ▼
     Finder scans QR
          │
          ▼
    Public Rescue Card
          │
          ▼
     Submit Sighting
          │
          ▼
       Owner notified

The goal isn't to replace GPS trackers or microchips.

It is to make the information surrounding a lost pet available, structured, and safer to share.

Why AI?

I didn't want to add AI simply because this was an AI-related challenge.

I wanted to use it where it could provide practical value.

Gemini is used to analyze visual characteristics such as coat patterns, eye color, and distinctive markings and generate a structured identification profile.

The application also provides informational preventive wellness guidance, while explicitly keeping medical diagnosis and treatment outside its scope.

AI-generated profiles are also localized according to the user's language.

Demo

🌐 Open the Live Demo →

The application includes a Demo Mode, so you can explore the main experience without creating an account.

The demo contains my seven cats:

Kiara · Golia · Meias · Vaquinha · Tigrinha · Peluda · Gamora

Try the Lost & Found flow with the demo data and explore how a finder would interact with a cat's public rescue passport.

Key flows

1. Register a cat

Create a digital identity and add health information.

2. Generate a QR collar tag

The QR code points to the cat's public safety passport.

3. Activate Lost Mode

The owner can mark the cat as missing.

4. Finder scans the QR code

The finder sees the relevant rescue information without seeing the owner's private contact details.

5. Submit a sighting

The finder can send information about where and when the cat was seen.

6. Owner receives the notification

The backend relays the sighting to the owner through Resend.

Code

💻 GitHub Repository →

The project is open source and built with:

React 19
Vite 6
TypeScript
Supabase PostgreSQL
Supabase Auth
Row Level Security
Gemini
Ollama
Mistral 7B
OpenCoder 8B
Resend
i18next / react-i18next
Vitest
React Testing Library
ESLint

How I Built It

This project was also an experiment in AI-assisted software engineering.

I used my own AI Software Engineering Framework 2.0 to orchestrate the development process.

The goal was not simply to ask an LLM to generate the application.

Instead, I treated AI agents as specialized members of an engineering workflow.

Human Supervisor
       │
       ▼
Chief of Staff
       │
       ▼
   Risk Router
    /   |   \
   ▼    ▼    ▼
Mistral OpenCoder Gemini
   \    |    /
    \   |   /
      Jidoka
         │
         ▼
   Human Approval
         │
         ▼
       Merge

Risk-based agent routing

Simple and low-risk tasks were delegated to local models running through Ollama.

🟢 Mistral 7B

Used for tasks such as:

documentation
simple UI changes
repetitive work

🟡 OpenCoder 8B

Used for:

CRUD
forms
implementation tasks

🔴 Gemini

Used for higher-risk tasks such as:

authentication
Row Level Security
AI integrations
architectural decisions

This allowed me to keep the more capable model focused on tasks where it provided the most value.

Jidoka Quality Gate

Every implementation had to pass a validation pipeline:

Lint
  ↓
Typecheck
  ↓
Tests
  ↓
Build
  ↓
Human Approval

If a validation step failed, the workflow stopped instead of allowing the problem to propagate.

This follows the Jidoka / Andon Cord principle from my framework:

When an anomaly is detected, stop the process and fix it before continuing.

The final release candidate passed:

Gate	Result
ESLint	✅ PASS
TypeScript	✅ PASS
Vitest	✅ 21/21 PASS
Production Build	✅ PASS

Privacy-first architecture

The public rescue passport deliberately does not expose:

owner's email
phone number
physical address

The finder communicates through a backend relay.

Sightings are persisted in PostgreSQL and the owner is notified through the Resend API.

This creates a simple separation:

Finder
  │
  ▼
Public Rescue Passport
  │
  ▼
Sighting
  │
  ▼
Backend
  ├── PostgreSQL
  └── Resend
          │
          ▼
        Owner

The finder can help without gaining direct access to the owner's private contact information.

Internationalization

English is the default language, with Brazilian Portuguese as a secondary locale.

I also wanted AI-generated information to respect localization.

The localized AI profiles are stored in PostgreSQL using JSONB:

{
  "en": {
    "description": "...",
    "personality": "..."
  },
  "pt-BR": {
    "description": "...",
    "personality": "..."
  }
}

This keeps the cat's identity data together while allowing the presentation to adapt to the user's language.

Design System

The application uses a custom Midnight Guardian design system.

The visual language combines:

Midnight Navy
Lavender
Emerald
Amber
Coral

The goal was to make the application feel like a safety product rather than a generic pet CRUD application.

🔐 Privacy & Safety

Privacy was treated as a product requirement rather than an afterthought.

The public QR page is intentionally limited to information that can help identify and recover the cat.

Owner PII is not rendered publicly.

The system also does not attempt to provide veterinary diagnosis.

Cat Guardian provides informational preventive wellness guidance and does not replace professional veterinary advice.

🚧 Current Limitations

Cat Guardian is a hackathon prototype.

It does not currently provide:

real-time GPS tracking;
GPS collar hardware integration;
veterinary diagnosis;
guaranteed pet recovery.

These could be explored in future versions.

For this challenge, I intentionally focused on the digital identity, QR-based rescue flow, privacy-preserving communication, and AI-assisted identification.

🎯 What I Learned

The biggest challenge wasn't building the features.

It was deciding what not to build.

It would have been easy to add GPS, maps, mobile applications, IoT devices, blockchain, push notifications, and many other features.

But the core idea was much simpler:

Give a cat a digital identity that can help protect, identify, and reunite them with their owner.

Everything else had to support that idea.

And the project became much stronger because of that constraint.

🐾 Built for seven cats

Cat Guardian started with a very personal question:

What information would I want to have if one of my cats disappeared tomorrow?

I would want their photo.

Their identifying characteristics.

Their health information.

Their vaccination history.

Their microchip information.

And, most importantly:

I would want the person who found them to have a safe way to contact me.

That's Cat Guardian.

Built for:

Kiara · Golia · Meias · Vaquinha · Tigrinha · Peluda · Gamora

🐾

Prize Categories

I'm submitting Cat Guardian for:

🏆 Best Use of Google AI

Gemini is used meaningfully in the application for:

AI-assisted visual identification profiles
feline characteristic analysis
preventive wellness assistance
localized AI-generated content

Google AI is also used as the high-risk agent in the AI-assisted engineering workflow.

🔗 Links

🌐 Live Demo

💻 GitHub Repository

Built for the DEV Weekend Challenge: Dog Days Edition.

Building a Robust API with Laravel, Clean Architecture, and SOLID Principles

Luis Fernando Richter — Fri, 17 Oct 2025 15:42:01 +0000

Excited to share a recent back-end project I architected and developed: the Favorite Products API. This isn't just another CRUD API; it's a practical case study on implementing Clean Architecture and SOLID principles with Laravel to build a secure, high-performance, and scalable solution.

The project is a RESTful API designed to manage user's favorite product lists, integrating with an external e-commerce service.

✨ Key Highlights & Challenges Overcome

Performance Optimization (N+1 Problem): I refactored the service layer to transform N+1 external API calls into a single, efficient bulk request (findProductsByIds), dramatically reducing latency.
Security First (IDOR Vulnerability): We patched a critical Insecure Direct Object Reference vulnerability by implementing strict, ownership-based authorization rules in the Form Requests. This is reinforced with feature tests covering 200, 401, and 403 status codes.
Decoupled & Testable Architecture: By using Dependency Inversion (Contracts/Interfaces), we fully decoupled our business logic from the external API client. This makes unit testing a breeze (just mock the interface!) and swapping data sources trivial.
Resilient Error Handling: Instead of letting external service failures fail silently (returning an empty 200 OK), the system now throws custom exceptions, which are caught by a global handler to return a meaningful 503 Service Unavailable response.

The entire stack runs on PHP 8.3/Laravel 12, PostgreSQL, and is containerized with Docker. We also have a comprehensive test suite using Pest and auto-generated, interactive documentation with OpenAPI (Swagger).

🔗 Open Source

The project is fully open-source. Feel free to explore the code, learn from the architectural decisions, or even contribute!

Check out the full source code on GitHub: lfrichter/favorite-products-api

I hope this can be a useful resource for anyone looking to deepen their understanding of modern back-end architecture.

Lightning-Speed Development with Bun and Hono ⚡

Luis Fernando Richter — Tue, 05 Aug 2025 13:00:00 +0000

Instead of just reading about the performance of Bun and the simplicity of Hono, I decided to put them to the test by building a Task Manager API. The result exceeded all my expectations and unveiled a new way of thinking about backend development.

![[lightning-speed-development-with-bun-and-hono.jpeg]]

Here are the highlights of this experience:

🏎️ Bun: The All-in-One Ecosystem That Eliminates Friction

Bun isn't just a runtime; it's a revolution in developer experience (DX).

Raw Performance: The server startup is instantaneous. In simple local benchmarks, my laptop hit peaks of 110,000+ requests/second. The memory usage was also incredibly optimized compared to Node.js.
Integrated Tooling: The best part is what you don't have to do. Bun comes with:
* ✅ An absurdly fast package manager.
* ✅ A native test runner (bun:test), allowing me to achieve 100% test coverage without setting up Jest, Vitest, or Mocha.
* ✅ Out-of-the-box support for TypeScript and JSX.

✨ Hono: The Magic of Simplicity for APIs

If Bun is the engine, Hono is the ultralight and aerodynamic chassis.

Minimalism and Performance: The code is clean and direct, with no boilerplate. The final bundle is just a few KBs, making it perfect for Edge Computing and serverless environments.
Total Flexibility: I wrote the API once, and I can deploy it anywhere: Bun, Deno, Cloudflare Workers, Vercel... Adhering to Web Standards makes all the difference.
TypeScript-First: The TypeScript experience is flawless. Autocomplete for route params, body, and headers is automatic, ensuring type safety across the entire application.

// The simplicity of Hono in action:
// A route to fetch all tasks with strong typing.

app.get('/tasks', (c) =\{
// 'c' (context) is fully typed\!
const tasks = db.query('SELECT \* FROM tasks').all();
return c.json(tasks);
});

🎯 The Dynamic Duo: Why Bun + Hono?

Together, they form the stack every developer deserves: fast, simple, and powerful.

True Agile Development: I went from "zero" to a fully tested CRUD in minutes, not hours. Less time configuring, more time creating value.
Fewer Headaches: Compared to a traditional stack (like MERN), the number of development dependencies and configurations to manage is drastically lower.
Production-Ready: The structure is naturally scalable and easy to test, creating a solid foundation for serious projects from the get-go.

The complete project is on my GitHub, with the full folder structure, tests, and documentation for anyone who wants to explore it.

👉 [https://github.com/lfrichter/hono-task-manager]

Ready to see for yourself? Try this combination and let me know what you think in the comments! 👇

I Built an Tool to AI Agent Testing

Luis Fernando Richter — Fri, 25 Jul 2025 00:06:12 +0000

Excited to share my latest open-source project: the AI Agent Tester!

As AI models become more integrated into our applications, how do we ensure their responses are consistent and reliable? Manually testing prompts is slow and doesn't scale. That's why I created this tool.

The AI Agent Tester automates the validation process. It reads prompts from a simple CSV file, sends them to an AI (like OpenAI's GPT), and checks the responses for expected keywords.

Here’s what makes it effective:

Intelligent Validation: It uses "stemming" with NLTK to recognize word variations (e.g., 'fly', 'flying', 'flew'), making validation more robust.
Detailed Reports: It generates a JSON report with the status (Success/Fail) for each prompt, along with the AI's full response.
Easy to Use: Built with Python and requires minimal setup. It even has automatic proxy support for corporate environments.

This project is for any developer or QA engineer working with Large Language Models who wants to add a layer of automated testing to their workflow.

It's open-source, and I would love to get your feedback or contributions!

Check out the project on GitHub: https://github.com/lfrichter/ai-agent-test

The Essence of Development: Unravelling the Complexities to Build High-End Applications

Luis Fernando Richter — Thu, 17 Jul 2025 20:28:44 +0000

As developers, we dive daily into a sea of lines of code, features, and challenges. But before any technological choice, there is a fundamental truth that guides the success of any application, especially those built for established businesses: the clear distinction between business complexity and technical complexity.

The Two Faces of Complexity

Business complexity resides in the rules, processes, and nuances of the very domain in which we operate. It would exist even without a single line of code. Think of the intricate tax regulations of an e-commerce site or the credit approval process of a financial institution. This is the essence, the "why" of our work.

Technical complexity, on the other hand, is what we, as developers, introduce with tools, frameworks, architectures, and implementation decisions. While necessary to bring the solution to life, it should serve the business, not the other way around.

From Distinction to Powerful Architectures

When we cultivate the ability to clearly perceive and map this difference, something magical happens: we elevate our application to a new level. By focusing on accurately modelling the business, isolating it from purely technical concerns, we open the doors to Clean Architecture and Hexagonal Architecture. These approaches allow us to build systems that are more maintainable, testable, and adaptable to business changes, as the core of the application—the business logic—remains cohesive and independent of external layers.

Deepening the Solution with Domain-Driven Design

And if the challenge is to build a robust system for a complex, large-scale business, Domain-Driven Design (DDD) becomes a powerful ally. By immersing ourselves in the domain, in the language of business experts, and translating it into a rich, cohesive model, we build software that truly solves business problems in an aligned and evolving manner.

Conclusion: Build for the Business First

In short, the journey to building high-level applications begins with a careful look at the nature of the complexity we face. By honouring the distinction between business and technology, we pave the way for solid architectures and, consequently, for the success of the product and the business it serves. Remember: understanding the core business is the first step to building solutions that truly make a difference.

My end-to-end automated YouTube video factory

Luis Fernando Richter — Sat, 12 Jul 2025 20:35:16 +0000

I'm excited to share the MVP of my latest personal project: a fully end-to-end automated YouTube video factory. This system is designed to transform a simple text idea into a complete, published video, supporting both short-form (Shorts) and long-form content.

It orchestrates a suite of powerful APIs and tools to automate the entire workflow:

Scripting: OpenAI API (GPT)
Voiceover: ElevenLabs API for high-quality TTS
Visuals: Flexible image generation via Replicate (SDXL) or a cost-effective alternative using the Pixabay API
Subtitles: Precise, locally-run transcription with OpenAI Whisper
Music: Royalty-free background music sourced from the Jamendo API
Assembly: A robust, two-step FFmpeg process that ensures smooth, "judder-free" animations
Publishing: Direct upload to YouTube via the YouTube Data API v3

Beyond just connecting APIs, the focus was on building a resilient and developer-friendly system. This includes:

A comprehensive health_check.py script to validate the environment.
Automated pytest tests for key integrations like Pixabay and Jamendo to handle API errors gracefully.
A full scheduling system for macOS using launchd to automate future uploads.

This project was a deep dive into system architecture, complex automation pipelines, and solving low-level integration challenges.

You can see the system's architecture in these diagrams:

Application Flowchart: https://bit.ly/4kzoxby
Sequence Diagram: https://bit.ly/46EHd6h

I'm always open to feedback and connecting with fellow developers!

Never Leave Your Inbox 📥 A Task Manager Powered by Simple Email Replies

Luis Fernando Richter — Mon, 09 Jun 2025 02:45:00 +0000

Hello everyone! This is my submission for the Postmark Challenge: Inbox Innovators on DEV.to. I decided to tackle a common problem for many of us: tasks that originate from emails often force us to switch contexts, copy-pasting content into a separate to-do application.

My solution? An application that transforms your email client into a fully-fledged, conversational task manager.

The Core Idea: Email as an Interface

Instead of just being a place where tasks arrive, what if the inbox could be the interface where you manage their entire lifecycle?

My project allows a user to:

Create a task by sending a simple email.
Receive an instant confirmation that creates a conversational thread.
Update, comment on, and complete the task just by replying to that thread with simple commands.

This creates a seamless workflow, keeping the user right where they are, without ever needing to open another app.

How It Works: The Conversational Flow

The magic happens through a combination of Postmark's Inbound and Outbound APIs and a command parser built in Laravel. The entire flow is conversational.

Here is a sequence diagram illustrating the process:

Let's see it in action with a simple story: updating a page on a website.

1. The First Email (Task Creation)

I send an email to the system's inbound address. The body contains a description of the task and some commands to set the priority and due date right away.

Subject: 📄 Update 'About Us' page on the company website

Body:

The 'About Us' page is outdated. Please update the text to reflect our new company values and add the latest team photos. The photo assets are in the shared drive.

#priority medium

My application receives this, creates the task, sets the priority, and cleans the description.

2. The Reply (Adding a Comment)

After receiving the confirmation email, I can reply to it to add a comment or ask a question.

Subject: Re: [TASK-2] 📄 Update 'About Us' page on the company website

Body:

The content team is ready to start, but they have a question first. 🤔

#comment Should we also update the individual team member bios, or just the main company description for now?

The application receives this reply, finds the original task, and attaches the new comment.

3. The Final Reply (Task Completion)

Once the work is done, a final reply with the #complete command is all that's needed.

Subject: Re: [TASK-2] 📄 Update 'About Us' page on the company website

Body:

Just confirmed with the director. For now, only update the main company description.

#comment The content team has confirmed the changes are now live on the site. Everything looks great. ✔️
#complete

The task is now automatically marked as completed in the UI.

The Tech Stack

To bring this idea to life, I used the following technologies:

Backend: Laravel 12
Email Processing: Postmark API (Inbound and Outbound)
Frontend: Livewire with Blade
UI & Icons: Tailwind CSS & Blade Heroicons
Testing: Pest (PHP Testing Framework)

A Glimpse into the Implementation

One of the core components is a CommandParser service in Laravel. It uses a simple but powerful regex-based approach to find and process commands within the email body. This service is responsible for updating the task's attributes or creating related records, like comments.

Another key piece was using Laravel's event system. By listening to the MessageSent event, the application captures the unique Message-ID of the outgoing confirmation email. This ID could be used in the future to build an even more robust system for threading replies.

Live Demo in Action

To demonstrate the application's flow in real-time, I recorded a short video showing the complete lifecycle of a task, from creation to completion, all managed via email.

youtu.be/NDFgcH2X1ZI

Conclusion

This project was a fantastic exercise in thinking about email not just as a destination, but as an interactive platform. By leveraging Postmark's powerful APIs, it's possible to build truly innovative and seamless workflows that meet users where they already are: their inbox.

Thank you for the challenge!

Find the full source code on my GitHub repository: Interactive-email-management