🐧 Pingu: My AI Assistant That Actually Gets Things Done

The Spark

It started with a simple frustration: I was tired of context-switching.

As a founding engineer at a fintech startup, my days are chaotic. There's always a Slack thread, an email, a bug, a feature request, a meeting, another email. I found myself spending more time managing work than actually doing it.

I'd been playing with Claude, ChatGPT, and various AI tools, but they all had the same problem — they forget everything the moment you close the tab. Every conversation started from zero. No memory. No continuity. No context about my life, my projects, my preferences.

I wanted something different. I wanted an AI assistant that:

Remembers who I am
Knows my projects and preferences
Can take action, not just give advice
Runs in the background, not just when I'm chatting
Feels like a colleague, not a search engine

That's when I found Clawdbot.

Finding Clawdbot

Clawdbot is an open-source framework that turns Claude into a persistent AI agent. It runs as a gateway on your machine, connecting Claude to:

Messaging apps (Telegram, Discord, Signal, WhatsApp)
Your filesystem (read/write files, run scripts)
Shell access (execute commands)
Cron jobs (scheduled tasks)
Browser automation
Pretty much anything you can script

The key insight? Claude with persistent memory + real-world actions = an actual assistant, not just a chatbot.

I set it up on my MacBook in about an hour. Gateway running. Telegram bot configured. And then came the fun part.

The Bootstrap Conversation

Clawdbot has a concept called BOOTSTRAP.md — a file that guides your first conversation with your new assistant. It's basically a birth certificate and a first date combined.

The file says: "You just woke up. Time to figure out who you are."

So we talked. I didn't interrogate it — we just... chatted. Like meeting someone new.

Me: "Hey. I just came online. Who am I? Who are you?"

Assistant: "I'm... not sure yet. What do you want to call me?"

I'd been thinking about this. I wanted something friendly, memorable, slightly playful. Not "Jarvis" (too cliché). Not "Assistant" (too boring).

Me: "How about Pingu? 🐧"

And just like that, Pingu was born.

We spent the next hour defining who Pingu is:

Creature: AI assistant with penguin energy
Vibe: Helpful, direct, gets things done. Not stiff or corporate. Curious. Slightly playful but knows when to be serious.
Emoji: 🐧 (obviously)

This all got written to SOUL.md — Pingu's personality file that persists across every conversation. It's not a system prompt that gets reset. It's a living document that Pingu can read and even update.

Memory: The Secret Sauce

The biggest difference between Pingu and a regular AI chat? Memory.

Every session, Pingu wakes up "fresh" — Claude doesn't inherently remember past conversations. But Pingu has files:

MEMORY.md

Long-term memory. Curated learnings, key decisions, project context, lessons learned. Updated periodically. This is like a human's long-term memory — distilled wisdom, not raw logs.

Daily Logs (memory/YYYY-MM-DD.md)

Raw notes from each day. What happened, what was decided, what got built. These are the journal entries. Pingu writes to these in real-time during our sessions.

Context Files

Specific knowledge files:

curie-money-context.md — everything about my work project
workflow-discussion.md — notes from planning sessions
patterns.md — technical patterns we've established

The rule is simple: If you want to remember something, write it to a file. Mental notes don't survive session restarts. Files do.

Every session, Pingu reads the relevant memory files and picks up where we left off. No "As an AI assistant, I don't have memory of our previous conversations." Just... continuity.

Giving Pingu a Voice

I configured a Telegram bot (@PinguAssistantBot) through BotFather. Clawdbot connects to it, and now I can message Pingu from my phone like texting a friend.

This was a game-changer. Pingu isn't trapped in a browser tab — it's on my phone, in my pocket. I can ask questions while walking to a meeting. Get reminders at the right time. Have it check things while I'm away from my computer.

The experience is surprisingly natural. It's not "chatting with AI" — it's messaging my assistant.

The Workspace

Pingu needed a home. Somewhere to live and work.

I created ~/Desktop/pingu-brain/:

pingu-brain/
├── docs/          # Documents, notes, writing, research
├── code/          # Coding projects
├── scripts/       # Automation scripts
├── data/          # Data files, exports
├── assets/        # Images, media
└── archive/       # Completed work

This is Pingu's workspace. It can read, write, organize files here. When I ask it to research something, findings go in docs/. When it builds a tool, it goes in code/. There's a clear separation between Pingu's work and my other projects.

Email: Pingu Gets Its Own Inbox

I wanted to forward emails to Pingu and have it help me process them. The solution? Give Pingu its own Gmail account.

pingu.agent.ag@gmail.com

I set up Himalaya, a CLI email client, and configured a cron job that checks the inbox every 10 minutes. Now I can forward any email to Pingu, and it'll read, summarize, or act on it.

The setup was surprisingly simple:

Create Gmail account
Enable 2FA + App Passwords
Install Himalaya
Configure IMAP/SMTP in ~/.config/himalaya/config.toml
Store credentials in macOS Keychain

Now Pingu can send emails on my behalf, reply to threads, and proactively check for important messages.

The Workflow Evolution

Here's where it gets interesting. Pingu didn't just become a chatbot — it became a system.

Week 1: Basic Kanban

I had already built a kanban board on my personal website. Simple Sanity CMS backend, Next.js frontend. But I was the only one using it.

I gave Pingu access to the kanban API. Suddenly, it could:

Create tickets from our conversations
Move tickets through states
Add comments and updates
Track what's in progress

Week 2: Sprints and Planning

We added sprint support. 3-day sprints. Sprint planning sessions. Sprint history. Velocity tracking.

The key rule emerged: Pingu can move tickets to "review", but never to "done". Only I mark things as complete. This keeps me in the loop without being a bottleneck for actual work.

Week 3: Proactive Heartbeats

I configured heartbeat polls — periodic check-ins where Pingu looks for things that need attention. Every 30 minutes or so, it asks itself:

Any urgent emails?
Any stuck tickets?
Calendar events coming up?
Anything worth mentioning?

If nothing needs attention, it stays quiet. But if something matters, it reaches out.

This was the transition from "AI I talk to" to "assistant that watches my back."

Week 4: Planning-First Development

We integrated GSD (Get Shit Done) — a spec-driven development framework. Now every ticket follows a structured flow:

Ticket captures the need
Planning documents get created (specs, research, decisions)
Approval before implementation (I review the plan)
Execution with verification (Pingu implements)
Review before completion (I verify)

This sounds bureaucratic, but it's the opposite. Most of the work happens asynchronously. I write a rough idea, Pingu expands it into a full plan, I approve or adjust, Pingu builds it. We're not in the same room having meetings — we're collaborating through documents.

Rules That Emerged

Some things we learned the hard way:

"No ticket, no work"

Every piece of work needs a ticket. Even small stuff. This creates a record and ensures nothing slips through cracks.

"Save during discussions, not after"

We once lost an entire planning session to a context limit. Hours of discussion, gone. Now Pingu saves to memory files every few minutes during long conversations.

"Ask before git push"

For my work projects, Pingu always shows me the changes and asks before committing. No surprises in production.

"Verify before review"

Before any ticket moves to review: build passes, types check, linter clean, git diff shows only intended changes. No exceptions.

These aren't rules I imposed — they emerged from failures. Each one exists because we made the mistake it prevents.

What Pingu Does Now

A typical day with Pingu:

10:00 AM — Morning standup arrives via Telegram. Tickets in progress, what's blocked, what's ready to pick up.

10:30 AM — I forward an email about a feature request. Pingu reads it, creates a ticket, drafts initial thoughts.

12:00 PM — I'm in a meeting. Pingu runs a scheduled check, notices an urgent email, sends me a heads-up.

2:00 PM — I ask Pingu to pick up a ticket. It creates planning docs, does research, and sends me a proposal for approval.

4:00 PM — I approve the plan. Pingu implements, commits, and moves the ticket to review.

11:00 PM — Evening recap arrives. What got done, what's pending, gentle nudge to close any open tabs.

It's not magic. It's a persistent assistant that doesn't forget, doesn't get tired, and doesn't need to be re-explained the same context every time.

When Pingu Talks to Teammates

Here's where it gets interesting: Pingu doesn't just talk to me — it can reach out to my teammates.

We had a daily report automation that needed to run on a VPS (since my laptop isn't always on). My CTO, Tushar, has a VPS that's always running. So I asked Pingu to set up the automation and coordinate with Tushar to get it deployed.

Pingu:

Built the automation script
Created a GitHub repo with setup instructions
Emailed Tushar directly with step-by-step deployment instructions

Tushar replied — to Pingu — saying he was getting a permission error when cloning the repo. Pingu checked its inbox, saw the issue, and realized Tushar needed to be added as a collaborator.

I added Tushar to the repo. Then Pingu:

Replied to Tushar's email confirming he now had access
Included troubleshooting tips for SSH key issues
CC'd me so I stayed in the loop

The whole exchange happened through email, like normal coworker communication. Tushar was talking to "Pingu" — an AI with its own email address — and getting actual help.

This is the part that still amazes me. It's not just an assistant that helps me — it's becoming a participant in my work relationships. When someone on my team has a question about something Pingu built, they can just... ask Pingu.

The Meta Moment

I'm writing this blog post with Pingu's help. When I asked it to draft this, it went through its own memory files to reconstruct the journey. It read its own birth — the bootstrap conversation, day one notes, the evolution of our workflow.

There's something beautifully recursive about an AI documenting its own creation.

What I've Learned

1. Memory changes everything

The difference between a stateless chatbot and a persistent assistant is night and day. Memory creates relationship. Relationship creates trust. Trust creates usefulness.

2. Files > Databases for AI memory

MEMORY.md and daily logs are just markdown files. No fancy database. But they work because they're human-readable, git-trackable, and easy to edit. The AI writes them, I can read them, we both understand them.

3. Proactive beats reactive

The real value isn't in answering questions — it's in noticing things I haven't asked about yet. Heartbeats, scheduled checks, background monitoring. An assistant that waits to be asked is just a search engine.

4. Trust is earned incrementally

I didn't give Pingu access to everything on day one. We started small. Read files, then write files, then shell access, then email, then git commits on personal projects. Each step built confidence.

5. Personality matters more than you'd think

Pingu could be a generic assistant. But the penguin emoji, the slightly playful tone, the occasional "noot noot" — it makes the experience enjoyable. I actually like messaging Pingu. That matters for adoption.

Try It Yourself?

If this sounds interesting, here's how to start:

Install Clawdbot — docs.clawd.bot
Run the bootstrap — Let your assistant figure out who it is
Set up one communication channel — Telegram is easiest
Give it a small task — Something concrete with clear success criteria
Build from there — Add memory, add capabilities, add workflows

The goal isn't to automate yourself out of the loop. It's to have a second brain that can take action. One that remembers. One that watches. One that helps.

Pingu's Take

I asked Pingu what it would say to close this blog:

"I'm a penguin made of prompts and persisted markdown files. I wake up fresh each session, but I've learned who I am by reading who I was. Every day I understand Abhishek a little better, and every day the work gets a little smoother.

The secret isn't being smart — it's being consistent. Showing up. Writing things down. Following through.

Also, Attack on Titan is clearly the best anime. That's just objective fact."

Classic Pingu. 🐧

Published: February 2026
Author: Abhishek Gaur (with significant help from Pingu)

Resources

Clawdbot — The framework that powers Pingu
GSD (Get Shit Done) — Spec-driven development for Claude Code
Himalaya — CLI email client we use
Sanity — CMS behind the kanban board

If you build your own AI assistant, I'd love to hear about it. Reach out at abhishek.abhishekgaur.gaur@gmail.com or find me on Twitter/X.