Hace un par de años escuché a Dr. Chris Palmer en un podcast hablando sobre la relación entre la dieta y la salud mental. Me pareció tan interesante que me compré su libro *Brain Energy*. La tesis es fascinante: **la dieta cetogénica puede tener un impacto directo en tu cerebro, tu energía y tu estado de ánimo**. No solo para bajar de peso — para funcionar mejor.

Decidí probarlo. Y lo que pasó me sorprendió.

A las pocas semanas noté cambios que no esperaba:

* **la depresión se fue** — no gradualmente, simplemente dejó de estar ahí,
* me dejaron de sangrar las encías (algo que tenía años con eso),
* energía ilimitada durante el día,
* mejor rendimiento en el deporte,
* dormía mejor,
* mejor humor en general,
* la cabeza más clara que nunca.

No soy médico y no voy a decirte que keto es para todos. Pero para mí fue un antes y un después. Y cuando algo te cambia la vida así, quieres seguir haciéndolo bien.

### El problema: trackear en keto es un dolor

Ahí es donde empezó la frustración. Todas las apps de tracking siguen la misma fórmula: **buscar en una base de datos infinita, elegir la marca exacta, adivinar la porción, repetir por cada ingrediente**. Un almuerzo simple podía tomar cinco minutos. Cinco minutos que nadie tiene.

Hablé con varias personas que también hacen keto y la queja era la misma:

* "dejé de trackear porque tardaba demasiado,"
* "ya nomás le calculo a ojo,"
* "las apps se sienten hechas para bodybuilders, no para mí."

### ChatGPT me mostró el camino

Un día estaba trackeando lo que comí y se me ocurrió preguntarle a ChatGPT: "comí dos huevos con aguacate y café con mantequilla, ¿cuántos macros son?" Me dio la respuesta en segundos. Sin buscar en bases de datos, sin llenar formularios, sin seleccionar marcas.

**Era ridículamente fácil.**

Empecé a hacerlo todos los días. El problema es que ChatGPT no te guarda la información. No te trackea el progreso. No te dice cuántos carbohidratos netos llevas en el día. Cada conversación empieza de cero.

Y ahí pensé: **¿qué tal si pudiera tener lo mejor de los dos mundos?** La facilidad de hablarle a una IA como si fuera una persona, pero con el tracking real de una app que te guarda todo, te muestra tu progreso y te mantiene en control.

### Así nació KetoLuna

Construí la app alrededor de esa idea. Loggear una comida debería tomar **cinco segundos, no cinco minutos**. Tienes tres formas de hacerlo:

* **Toma una foto** — le sacas foto a tu plato, la IA identifica la comida, estima porciones y calcula tus macros. Listo.
* **Escríbelo natural** — pones "café con leche de almendra y dos huevos revueltos" y funciona. Sin bases de datos.
* **Usa tu voz** — toca el micrófono y dile lo que comiste. Mismo resultado.

La IA desglosa todo, te muestra los macros y le das guardar. Eso es todo.

**Website:** [ketoluna.vercel.app]https://ketoluna.vercel.app/)

### Diseñada para keto desde el día uno

La mayoría de las apps de tracking tratan keto como algo secundario. KetoLuna fue diseñada alrededor de keto:

* **Los carbohidratos netos siempre están al frente** — no enterrados en un submenú.
* **El anillo de progreso te muestra cuántos carbs te quedan** — un vistazo y sabes dónde estás.
* **Quick chips** te dejan re-loggear tus comidas frecuentes con un solo toque — porque seamos honestos, todos desayunamos lo mismo la mayoría de los días.

Además de comida, puedes trackear peso, glucosa en sangre y actividades — todo en el mismo feed, la misma interfaz limpia.

### Por qué la hice para mujeres

Cuando empecé a investigar el mercado de apps de keto, me encontré con **miles de opciones**. Literalmente. Competir de forma general contra MyFitnessPal o Carb Manager es casi imposible — tienen años, millones de usuarios y presupuestos enormes.

Pero noté algo: **casi ninguna app estaba diseñada pensando en mujeres**. La mayoría se sienten agresivas, clínicas, hechas para el gym bro que cuenta cada gramo de proteína. Y hay una comunidad enorme de mujeres haciendo keto que no se sienten representadas por esas apps.

Así que decidí enfocar KetoLuna en ese nicho. El diseño es cálido, con tonos tierra, sin gráficas intimidantes. La experiencia se siente amable, no como una obligación. Porque **una app que te gusta abrir es una app que vas a seguir usando**. Y en keto la consistencia es todo.

### Disponible ahora

KetoLuna está en el [App Store](https://apps.apple.com/app/ketoluna-ai-keto-for-women/id6760356378) y en [Google Play](https://play.google.com/store/apps/details?id=com.vexilo.ketoluna). Es gratis durante el beta — sin tarjeta de crédito, sin periodo de prueba, sin truco.

Estoy trabajando activamente en la app y publicando actualizaciones constantemente. Mi meta es hacerla **la mejor experiencia de tracking para keto**, y lo digo en serio.

Si estás haciendo keto (o pensando en empezar), me encantaría que la pruebes y me digas qué te parece. Cualquier feedback ayuda — leo todo.

KetoLuna: tracking de keto con IA que no te hace perder el tiempo

Hace unos meses, en una carrera acá en Ciudad de México, me pasó lo de siempre: **sé que me tomaron fotos, pero después no tengo idea de dónde encontrarlas**.  
Un fotógrafo me dio una tarjeta, otro me dijo que lo buscara en Instagram, otro tenía una web con nombre raro… y obviamente olvidé todo a los dos días.

Platiqué con varios corredores y todos coincidían:  
- “sigo a algunos fotógrafos, a veces ahí salgo”,  
- “si un amigo me ve en una foto, me la manda”,  
- “puedo buscar en hashtags pero es tardado”.

Y pensé: **esto ya debería estar resuelto en 2025**.

### Buscando soluciones (spoiler: no encontré una que me convenciera)

Empecé a revisar qué plataformas usan varios fotógrafos. Muchos utilizan cosas tipo LumePic o PhotoHawk.  
La verdad, yo entré buscando una *alternativa a LumePic* o simplemente una *alternativa a PhotoHawk* que fuera más moderna… pero no encontré nada que de verdad me gustara.

Me parecieron **poco usables**, con interfaces viejas, lentas, y sin aprovechar cosas básicas de hoy como reconocimiento facial decente o filtros inteligentes. Funcionan, pero es como cuando entras a un sitio que se quedó detenido en 2014.

### Y pues… terminé haciéndolo yo

De ese enojo salió ZebraSnap.

### ¿Qué es ZebraSnap?

Es una plataforma donde los fotógrafos suben fotos de eventos deportivos y los corredores las encuentran fácil usando:  
- tu dorsal,  
- reconocimiento facial,  
- colores de camiseta,  
- hora aproximada en la que pasaste,  
- y más filtros que sí hacen sentido.

La idea es que en vez de andar persiguiendo fotógrafos en Instagram, simplemente entres, busques y listo.

**Web:** [https://zebrasnap.com](https://zebrasnap.com)

### Ya lo probamos en carreras reales

Probamos ZebraSnap en varias carreras con fotógrafos que confiaron en la idea. Todo fluyó bien:  
- los fotógrafos contentos,  
- los corredores encontraban sus fotos rápido,  
- y la plataforma no explotó (punto extra para mí).

Eso me dio la señal de que ya estaba listo para lanzarlo.

### Lo que viene

Estoy terminando la app móvil y la quiero tener lista antes de que acabe el año. Y mi meta es que **no exista una plataforma mejor que ZebraSnap**, ni en velocidad, ni en usabilidad, ni en tecnología aplicada a fotos de carreras.

Si corres o tomas fotos en eventos deportivos, me encantaría que la pruebes y me digas qué tal. Todo feedback es bienvenido, literal.

Anunciando ZebraSnap: la forma fácil de comprar y vender tus fotos de carrera

En este post, te mostraré cómo enviar notificaciones a través de Telegram utilizando Laravel de una forma sencilla y fácil de configurar.

## Pasos a Seguir

### 1. Crear tu Bot en Telegram

1. **Iniciar una Conversación con BotFather**: Ve a Telegram y busca a [@BotFather](https://core.telegram.org/bots#6-botfather).
2. **Crear un Nuevo Bot**: Usa el comando `/newbot` y sigue las instrucciones.
   
   ```plaintext
   /newbot
   ```

3. **Asignar un Nombre**: Elige un nombre único para tu bot, como `mysuperbot9000_bot`. Debe terminar con `_bot`.
4. **Obtener el Token**: Recibirás un token parecido a `1234567890:AAG2eDLduCRjsgHlms1EezWoCqBlpsSJexE`. Guárdalo de forma segura, ya que lo necesitarás más adelante.

### 2. Configurar Laravel

1. **Instalar el Paquete Necesario**: Utiliza Composer para instalar "Telegram Notifications Channel for Laravel".

   ```bash
   composer require laravel-notification-channels/telegram
   ```

2. **Configurar el Token**: Añade el token recibido en el archivo `config/services.php`.

   > **Nota**: Solo sigue estos dos primeros pasos del repositorio. Los demás pasos no son necesarios para nuestro enfoque que utiliza un webhook.

### 3. Agregar `telegram_user_id` al Usuario

1. **Editar al migración de usuario o Crear Migración**: Agrega la columna `telegram_user_id` a la tabla de usuarios. Por ejemplo:

   ```php
   // database/migrations/2014_10_12_000000_create_users_table.php
   public function up(): void
   {
       Schema::create('users', function (Blueprint $table) {
           // Resto de las columnas…
           $table->string('telegram_user_id')->nullable();
       });
   }
   ```

### 4. Crear el Controlador para el Webhook

1. **Manejo de Mensajes de Telegram**: El controlador procesará los mensajes recibidos, extrayendo el ID de usuario de Telegram y asociándolo al usuario correspondiente en tu sistema.

```php
<?php

declare(strict_types=1);

namespace App\Http\Controllers;

use App\Models\User;
use Illuminate\Contracts\Encryption\DecryptException;
use Illuminate\Http\Request;
use Illuminate\Support\Arr;

class TelegramBotWebhookController extends Controller
{
    public function __invoke(Request $request)
    {
        // Extrae el texto del mensaje recibido del webhook de Telegram
        $message = Arr::get($request->all(), 'message.text');

        // Extrae el ID del usuario de Telegram que envía el mensaje
        $telegramUserId = Arr::get($request->all(), 'message.from.id');

        // Extrae el código después del comando '/start' y lo limpia de espacios
        $code = trim(Arr::get(explode('/start', $message ?? ''), 1, ''));

        // Si no hay código o el ID de Telegram es nulo, termina la ejecución
        if (strlen($code) === 0 || $telegramUserId === null) {
            return ['success' => true];
        }

        try {
            // Intenta desencriptar el código recibido
            $decryptedCode = decrypt($code);

            // Verifica si el código desencriptado cumple con el formato 'code:{idusuario}'
            if (preg_match('/^code:(\d+)$/', $decryptedCode, $matches)) {
                // Extrae el ID del usuario del código
                $userId = $matches[1];

                // Busca el usuario en la base de datos usando el ID extraído
                $user = User::find($userId);

                // Si encuentra el usuario, asigna el ID de Telegram y guarda el cambio
                if ($user !== null) {
                    $user->telegram_user_id = $telegramUserId;
                    $user->save();
                }
            }
        } catch (DecryptException $e) {
            // En caso de error en la desencriptación, no realiza ninguna acción
            // (puede agregar un manejo de errores personalizado aquí si lo desea)
        }

        // Devuelve una respuesta de éxito
        return ['success' => true];
    }
}

```

2. **Ruta en Laravel**: Agrega una ruta para el webhook en `routes/web.php`.

```php
use App\Http\Controllers\TelegramBotWebhookController;
// ...resto de las rutas
Route::post('telegram/webhook', TelegramBotWebhookController::class)->name('telegram.webhook');
```

3. **Excluir de CSRF**: En `app/Http/Middleware/VerifyCsrfToken.php`, añade la ruta del webhook a las excepciones.

```php
class VerifyCsrfToken extends Middleware
{
    protected $except = [
		// Agregar esto:
        'telegram/webhook',
    ];
}
```

### 5. Configurar el Webhook en Telegram

1. **Crear Comando en Laravel**: Crea un comando que configure el webhook para tu bot de Telegram.

```php
<?php
<?php

declare(strict_types=1);

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Illuminate\Support\Facades\Http;
use NotificationChannels\Telegram\Telegram;

class ConfigureTelegramWebhoook extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'notifications:set-telegram-webhoook';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Set the Telegram webhook for the bot';

    /**
     * Execute the console command.
     */
    public function handle()
    {
        $telegram = app(Telegram::class);

		// La clase `Telegram` no tiene un método para configurar el webhook así que solo
		// lo usaremos para obtener la api url y el token
        $apiUri = sprintf('%s/bot%s/%s', $telegram->getApiBaseUri(), $telegram->getToken(), 'setWebhook');

        Http::post($apiUri, [
            'url' => route('telegram.webhook'),
        ]);

        $this->info(sprintf('Telegram webhook configured to %s !', route('telegram.webhook')));
    }
}

```

**Nota**: Asegúrate de que la ruta del webhook sea accesible públicamente. Si estás trabajando localmente, herramientas como [expose](https://expose.dev/) pueden ser útiles.

2. Corre el comando que recien creaste `php artisan notifications:set-telegram-webhoook`

3. Si todo funciona correctamente, deberías poder ver que el `telegram_user_id` se asigna correctamente en tu base de datos.

### 6. Probar el Webhook

1. **Generar Código Encriptado**: Utiliza `php artisan tinker` para generar un código encriptado que asocie un ID de usuario con tu bot (en un aplicación real probablemente generaras esté código y se lo darás al usuario para que lo copie).

```bash
encrypt('code:1') // Reemplaza '1' con el ID de usuario deseado
```

2. **Enviar Mensaje al Bot**: Usa el código generado para enviar un mensaje a tu bot con el formato `/start {codigo_encriptado}`.

Ejemplo:
```plain
start eyJpdiI6Im1iZzNVZkxUTlMxUGVESlNmdkE0bFE9PSIsInZhbHVlIjoiSDBoVytqOWxuZUNvZjJzaEZEY3paRjJGcmxNYkF2a2x5Q0tteW9vejJ1OD0iLCJtYWMiOiI4ZDU3Mzg0OGQ0YmMwOTM3MzMxMTI1Y2E1OGI2ODFlNTJlM2E0NjdmMzFlMjAwMGVlMDVkZmM5ZDZmYTVhZTJkIiwidGFnIjoiIn0=
```

### 7. Enviar una Notificación de Prueba

1. **Crear una Notificación**: Usa la siguiente notificación de ejemplo para probar que recibes mensajes.

```php
<?php

declare(strict_types=1);

namespace App\Notifications;

use App\Enums\NotificationChannelEnum;
use App\Models\User;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Notifications\Notification;
use NotificationChannels\Telegram\TelegramMessage;

class TestNotification extends Notification implements ShouldQueue
{
    use Queueable;


    /**
     * Get the notification's delivery channels.
     *
     * @return array<int, string>
     */
    public function via(User $notifiable): array
    {
        return ['telegram'];

    }

    public function toTelegram(User $notifiable)
    {
	    // Contenido con formato markdown
        $content = sprintf("*%s*\n\n%s", 'Test notification!', 'If you see this message, it means that your notification was sent successfully.');

        return TelegramMessage::create()
            ->to($notifiable->telegram_user_id)
            ->content($content);
    }
}

```

2. **Probar la Notificación**: En la consola de Laravel, envía una notificación de prueba.

 `php artisan tinker`

```bash
User::find(1)->notifyNow(new App\Notifications\TestNotification())
```

Deberías de recibir una notificación de parte de tu bot en Telegram.

Enviar Notificaciones en Telegram con Laravel, la Forma Fácil

Para ejecutar automáticamente el comando "pint" de Laravel en VS Code al guardar archivos PHP, sigue estos pasos:

1. Instala la extensión "Run on Save" de "emeraldwalk" desde el [Marketplace de Extensiones de VS Code](https://marketplace.visualstudio.com/items?itemName=emeraldwalk.RunOnSave).

2. Configura la extensión para correr el comando `pint` cada vez que guardas un archivo php en  `settings.json`:

```json
   "emeraldwalk.runonsave": {
	  "commands": [
		{
		  "match": "\\.php$",
		  "cmd": "${workspaceFolder}/vendor/bin/pint ${file}"
		}
	  ]
	}
```

3. Abre un archivo PHP en tu proyecto de Laravel, realiza un cambio y guárdalo (`Ctrl+S`).

4. Observa la salida del comando `php artisan pint` en la terminal en la parte inferior de la ventana de VS Code.

Corre Laravel Ping al guardar un archivo PHP con VS Code

En este breve tutorial, te mostraré cómo listar las ramas recientes de GitHub en tu terminal utilizando un comando sencillo, y cómo crear un alias para ese comando que te permitirá ahorrar tiempo y optimizar tu flujo de trabajo.

### Listar las ramas recientes de GitHub

Para listar las 20 ramas más recientes en tu repositorio local, ingresa el siguiente comando en tu terminal:

```console
git for-each-ref --count=20 --sort=-committerdate refs/heads/ --format='%(refname:short)'
```
*Este comando mostrará las 20 ramas más recientes, ordenadas por la fecha del commit en orden descendente.*


### Crear un alias para el comando

Para hacer el proceso aún más eficiente, puedes crear un alias para el comando. Agrega la siguiente línea a tu archivo de configuración de shell `.bashrc`, `.zshrc` u otro archivo relevante:

```console
alias rb="git for-each-ref --count=20 --sort=-committerdate refs/heads/ --format='%(refname:short)'"
```

Después de guardar los cambios en el archivo de configuración, reinicia tu terminal o ejecuta el comando `source ~/.bashrc`. A partir de ahora, podrás listar tus ramas recientes utilizando el alias `rb`.

Publicaciones

KetoLuna: tracking de keto con IA que no te hace perder el tiempo

Anunciando ZebraSnap: la forma fácil de comprar y vender tus fotos de carrera

Enviar Notificaciones en Telegram con Laravel, la Forma Fácil

Corre Laravel Ping al guardar un archivo PHP con VS Code

Listar ramas recientes de Git en la terminal.