I forked Garry Tan’s GBrain because I thought product managers needed a better way to write PRDs. That was partly right. It does help with PRDs, but the more useful thing was not the document. It was the memory behind the document: which customers felt the pain, where the evidence came from, what sales and support had already heard, and whether the product had tried to solve something like it before.

In a large product org, the hard part is rarely writing the artifact. The hard part is reconstructing reality from different stakeholders, roadmap review, launch decision, or customer call where the decision signals matter. PM Brain became the single source of truth acting like customer memory.

Problem: B2B PM’s signals are scattered and mostly unstructured text

A PM doesn’t make a decision from one source. They pull from customer calls, support tickets, product analytics, adoption data, sales blockers, NPS, Slack threads, prior launches, and gut instinct. Before automating any PM artifact, I asked three questions: where do PMs get the sources they use to decide, where do those decisions enter the build lifecycle, and what comes out the other side. That became the PM Brain.

For example, sales says the UI is blocking a deal. Support sees repeated tickets. Product analytics shows low adoption in one part of the funnel. Customer calls have the quote in plain English. Feature request logs have five variations of the same ask. NPS comments have the frustration, usually with less diplomacy. Any one of those signals is easy to dismiss. Together, they are the product story.

Why I used GBrain instead of plain RAG

Most RAG systems are built for lookup. Embed documents, search chunks, summarize the results, hope the answer is grounded enough. That is fine when the job is “find the policy.” It is weak when the job is “explain why this customer pain keeps showing up across six systems and what we already tried.”

Product work is graph-shaped. Customers connect to pain points. Pain points connect to feature themes. Feature themes connect to roadmap items, PRDs, release notes, support tickets, usage patterns, blocked deals, and old decisions nobody remembers until they become expensive again.

GBrain fit that shape better. Its hybrid search combines semantic search, keyword search, and graph traversal. It can cite sources and say when it does not know something. It also wires the graph on ingest without paying for an LLM call on every edge, which matters once the corpus gets large. That last part is not glamorous. It is the difference between a demo and something you can afford to keep running.

GBrain’s hybrid search runs three retrieval modes at once (vector for semantic lookup, keyword for exact names, graph for relationships), backs answers with citations, and flags what it doesn’t know instead of guessing. It also auto-wires the graph on ingest with zero LLM calls, which keeps the whole thing cheap to run at scale.

If you want to see gbrain tutorials: GBrain shipped in April 2026 and picked up a fast following. MarkTechPost has a full install-to-MCP walkthrough with real terminal output, and Vectorize’s review is a fair-minded look at where the project holds up and where it doesn’t. Worth reading before you fork it.

The graph is grounded with accounts

I anchored on account (customer) data first, since accounts are the one object product, sales, CS, and support all share. From there I extracted pain-point themes from the qualitative data: accounts, pain points, customer asks, feature themes, product areas, and the evidence behind each one. Edges connect accounts to pain points, pain points to feature themes, and feature themes back to artifacts like PRDs and release notes.

The edges matter more than the nodes. An account links to a pain point. A pain point links to a feature theme. A feature theme links to evidence, prior artifacts, and eventually release notes. That changes the question from “find notes that mention Feature X” to “which accounts feel this pain, what did they say, which deals are blocked, and have we already shipped something related?” That is closer to the real PM question.

End users connect Claude through MCP and ask the brain directly. The prototype started as PM tooling, but it quickly escaped the PM box. PMM, account teams, and leadership all wanted different views of the same customer memory. The current graph has 100k+ pages and 225k+ edges.

The surprise use case was meeting prep

I originally built this to gather customer info, automate writing PRDs and build features grounded by customer asks. The better (and more common) use case turned out to be walking into a customer meeting prepared with customer context. That sounds obvious after the fact. Go-to-market teams talk to customers constantly, product hears a fraction of those conversations, and customers repeat the same context to sales (with turnovers), support, CS, PM, and leadership until someone finally pieces together the story.

Nobody enjoys that. Customers especially. The brain can generate an account prep note before a meeting: recent pain points, open asks, related product areas, prior conversations, evidence links, and what changed since the last touch. The PRD assistant was useful, but the account memory was valuable to more people.

The brain generates a prep note like:

Account teams used it before calls. Partner marketing pulled pain themes. Execs used it for account prep. PMs used it to separate loud requests from patterns. The questions changed too: what should I know before this customer meeting, which pain points show up in accounts over $1M ARR, what are customers saying about onboarding friction, which product areas create the most repeated support pain, and did we already promise something related?

Keep the brain separate from the UI

The meeting prep dossier above is not hand assembled. Account briefs run through a deterministic HTML generator with an agentic search and summarization step, so the same account produces the same brief when the data has not changed. That matters because a brief that changes on every rerun is not something you can trust in a live meeting.

The graph stays underneath as the shared memory layer. The view on top can change based on user’s preference. Today it is an account brief. Tomorrow it can be a pain point leaderboard, a launch-readiness view, a PRD evidence pack, or a product area dashboard. The important design choice is that the AI agent nor the UI does not own the memory. The graph does.

Where this goes next

The next version combines unstructured and structured data. The PM Brain has qualitative signal. The data warehouse has structured signal: usage, adoption, retention, feature telemetry. The real product is both, which means a PM can finally ask whether the customers complaining about a workflow actually show the same pain in their usage data, or whether adoption moved after a feature shipped.

Release notes are next on the ingestion list, since they close the loop end to end. Slack and email are harder. The signal is real but the noise is brutal, and ingesting them blind is how you build a haunted attic with embeddings.

The main lesson is separating the brain vs UI

As you may have heard many times: AI is not the solution, it is the vehicle that takes you to the solution. In this case AI is used two ways: building the brain, and building the customized dashboard (or PRDs / other artifacts). Once an AI agent can tab into this brain, it unlocks myriads of use cases by building any custom solutions on top of it.

This is not a sponsored post. I experimented the tools to bring you my honest take for my use case.

I’ve been experimenting with AI video creation, and it feel honestly feels like magic. What used to require specialized tools, production experience, and a decent amount of coordination can now start with a prompt, a reference image, a voice recording, and a willingness to iterate. This must the the feeling of a non-coder vibe coding for the first time.

For this experiment, I wanted to see if I could create a short cinematic video where a digital version of me teaches a concept while moving through a scene. The final result came from a HeyGen avatar created from one picture and a voice recording, combined with Seedance video generation through HeyGen. I also tested the same prompt in Google’s Gemini Omni using the same picture and voice.

The interesting part is that each tool exposed a different strength and failure mode.

Video generated by HeyGen in One Shot Prompt

The prompt is the new production brief

Here’s the one-shot prompt I used:

Will (avatar) moves through a massive early industrial factory floor. Belts, gears, pulleys, brass machines, and workers moving parts from station to station. Warm sparks from machinery. Golden industrial light. Camera tracks alongside him continuously throughout — medium close-up, never static. No music. Will moves through the factory as he teaches. He places one hand briefly on a moving conveyor rail. He picks up a small metal part — examines it briefly — sets it back into the workflow and keeps walking. Natural fluid movement throughout. He looks directly at camera the entire time. Will teaches directly to camera while moving.

Exact words only:
“AI agents are not magic employees. They are workflows with a brain in the middle. If the steps are vague, the agent wanders. If the inputs, tools, checks, and handoffs are clear, suddenly it starts looking useful.”

At 11 seconds — camera tracking alongside him — a weathered wooden door becomes visible ahead. It is already there. Set into a brick factory wall between two machines. It has always been there. He approaches it still looking at camera still talking. He pushes it open — warm office light already fully established beyond it. Bookshelves visible. Window with garden. Microphone. He walks through still looking at camera. Crosses to his desk. Sits naturally into exact seated position from reference image. Looks at camera. Ready. Camera tracks continuously from factory floor through door to seated position. Never cuts. Never loses his face. Clear and stable facial features. Widescreen. Shallow depth of field. Film grain. 4K HD. No blur. No ghosting. No music.

This prompt is doing the work that used to be spread across a creative brief, storyboard, shot list, script, camera direction, and editing notes. It defines the scene, movement, camera behavior, dialogue, timing, lighting, facial continuity, and constraints.

How I did it with HeyGen

If you’ve tried recording yourself in a video, you’d know the setup: lighting, camera anxiety, microphone issues, retakes, editing, and the somehow universal truth that recording a 30-second clip can easily take 45 minutes.

HeyGen is built for businesses and creators who need to produce polished videos without turning every idea into a full production project. It can turn scripts into videos, photos into videos, upscale content, auto-edit clips, and handle many of the workflows you would expect around explainer videos, product videos, training content, and social content.

Because of that focus, HeyGen has a strong avatar layer. I gave it a picture and a short voice recording, and it created a usable digital version of me that could be applied across different video formats. That is the real unlock: once the avatar exists, the workflow becomes repeatable. You can create founder updates, product explainers, sales videos, training modules, or multilingual versions of the same message without recording from scratch every time.

What Seedance added through HeyGen

Seedance was the cinematic layer inside the HeyGen workflow. The factory floor, moving camera, industrial lighting, physical motion, door transition, and office reveal came from the video generation side. That is what changed the output from a basic talking-head avatar into something closer to a short visual story.

I did not use Seedance as a separate standalone workflow. I used it directly through HeyGen’s Seedance integration, which made the process much easier. That combination is important: HeyGen handled “make this feel like me,” while Seedance handled “make the scene feel alive.”

Together, they got much closer to the result I wanted than either layer would have on its own. The avatar gave the video identity. The generated scene gave it motion and metaphor.

Google Gemini Omni: what it did well, and where it struggled

I also tested the same prompt in Google Gemini Omni using the same picture and voice. The avatar likeness actually worked pretty well. It looked like me, which was a pleasant surprise and a big improvement over what I expected.

Where Omni really shines is workflow simplicity. Uploading the avatar image and voice felt more integrated. With HeyGen, avatar creation and video generation are more separate steps. With Omni, the process felt easier and more unified: give it the image, give it the voice, give it the prompt, and iterate from there.

The tradeoff was prompt adherence. My prompt specifically asked for a continuous tracking shot with no cuts, but Omni still produced frames that felt cut together rather than one seamless camera move. The output was good, but it took four tries, and even then it did not fully preserve the “single continuous shot” requirement.

That is an important distinction. Omni was strong on ease of use and likeness. HeyGen + Seedance was stronger for getting closer to the specific cinematic structure I wanted. Neither workflow was perfect, but each revealed where the tools are heading.

Quick comparison: Gemini Omni vs. HeyGen

The bigger lesson: vibe coding and vibe video are more alike than they look

AI video creation is starting to feel a lot like vibe coding. With vibe coding, the prompt is only part of the workflow. You still need the right tool, whether that is Claude Code, Codex, Cursor, Replit, or whatever comes next. You still need to understand the system you are building, and you still need to know when the output is wrong, fragile, overcomplicated, or quietly making a mess behind the scenes.

AI video has the same pattern. The prompt matters, but the tool matters too. HeyGen, Seedance, and Gemini Omni are not interchangeable. Each has different strengths, assumptions, and failure modes. The same prompt can produce something impressive in one workflow and something unusable in another.

And just like with coding, judgment is the real multiplier. You need to know what good looks like. You need taste. You need to understand pacing, message clarity, visual metaphor, audience expectations, and where the model is likely to drift. You need to decide what is worth fixing and what is good enough to ship.

This is the part people sometimes miss about AI tools. They lower the barrier to starting, but they do not remove the need for judgment. In fact, they make judgment more important because the iteration cycle is so fast. You can generate five versions quickly, but you still need to know which one works and why.

What this changes

The big shift is not just that AI can generate video. The big shift is that video creation is becoming prompt-native and iteration-native.

Before, the hard parts were equipment, editing tools, production skill, filming, and time. Now, a lot of that friction is compressed. The new bottleneck is clearer: can you describe what you want, choose the right tool, evaluate the output, and iterate toward something useful?

That is a meaningful change for builders, founders, marketers, educators, and anyone who has ideas but not a production team sitting around waiting for instructions. You can test ideas in minutes, turn abstract concepts into visual stories, create content without waiting on a full production cycle, and experiment with formats that would have been too expensive or annoying before.

The first output will still be weird sometimes. That is part of the deal. But the speed of learning is the unlock.

My takeaway

AI video is not replacing creativity. It is compressing the distance between an idea and something that’s not AI slop.

That does not make everyone instantly great at video, just like AI coding tools do not make everyone instantly great at software. But they do give more people the ability to experiment, prototype, and publish.

And once that distance collapses, the builders have an advantage. Builders are not waiting for permission, perfect tools, or a studio budget. We are trying stuff, learning what works, and getting a little better each time.

Right now, that might be the whole game.

If you’re still using AI as a chatbot to summarize emails that you won’t read anyway, you’re using it wrong.

I decided to use mine to research stocks for me as a hobby project.

The Context: News Overload

I spend too much time at the intersection of AI and stocks. For a while, my setup was basic: Hermes agent that summarizes 20+ newsletters into a morning email. It felt productive, but it was a pretty weak use case.

I was reading AI and stock news, but none of it was compounding. I’d find a great AI thesis on Monday in a podcast, and by Friday, I’d forgotten how it connected to the semiconductor bottleneck I read about on X three weeks ago.

Then Andrej Karpathy posted about the “LLM Wiki” — the idea that AI shouldn’t just answer questions, it should maintain a persistent, evolving artifact of knowledge.

I realize I never retain any knowledge, and when I did, they were siloed. I needed a brain that remembers and connects the dots for me.

My setup:

• Agent harness: Hermes Agent + custom skills

• Model: GLM-5-Turbo

• “Brain”: Andrej Karpathy’s LLM wiki

The Build: From Script to Strategy

My first prompt was the following:

Do a daily scan of: https://x.com/aleabitoreddit https://x.com/midascabal and compile a list of stocks that is a buy, speculative, on the radar, or any other category that you can think of. I want to get the signals vs noise from all the posts he’s making. Post in “market-updates” channel in Slack

The result after a single prompt was pretty good, but mechanical with no reasoning.

After feeding it my own watchlist, my first daily market briefing and asking it to hunt for asymmetric plays, my 8am “market update” look like a big watchlist and news flash:

The first version of the scanner was like a freshman intern: eager, but not thinking strategically. It could find the tickers, but it couldn’t tell me why they mattered in the grand scheme of things.

To move from a basic watchlist to a high-conviction research system, I had to build in these “missing” layers:

• Macro Contextualization: Raw stock mentions are useless without context. I forced the agent to layer in “Strategic Headlines” — connecting a ticker mention to things like interest rate shifts, hyperscaler AI CAPEX (the “big spenders”), and specific supply chain bottlenecks.

• The Conviction Hierarchy: Not all signals are created equal. I implemented a strict pruning system that categorizes tickers into a hierarchy: Conviction (strong thesis), High Signal (unusual activity), and Watchlist (waiting for a pullback or more data).

• Recursive Source Discovery: The agent now actively hunts for its own replacements. It scans for new X accounts that aren’t just “shilling” but are mapping out supply chains.

• Multimodal Inputs: Since some of the best alpha is buried in an hour-long deep dive, I’m integrating transcripts from YouTube and Podcasts as signal sources.

Want more hands-on AI-agent workflows, prompts, and experiments? Subscribe to Vibe Coding Dad.

Subscribe now

Tweaks and fine tuning

After running for a few days, my lists, research, and scoring system started to pile up. It was difficult for my agent to find things.

I told V (my “vibecodingdad.com” assistant) to set this up, and it auto-organizes the content. Simply pointed V to Karpathy’s LLM-wiki page.

Self improvements

You’re an analyst for asymmetric trades with great fundamentals — what else should we add to our pipeline for research, signals, and macro?

You are constantly improving this as you go. always learning what works what doesn’t, and always change things up. remember you’re an agent that makes money from asymmetric trades and always hunting for new opportunities

Here is the architecture of how it actually works:

1. The Signal Scanner: Every morning at 7:45 AM, it scrapes the last 24h of tweets from deep-research accounts (think supply chain nerds, not engagement-baiters).

2. The Noise Filter: It extracts cashtags and classifies them by conviction. It’s trained to ignore “I called this at $X” posts and focus on actual thesis-driven data.

3. The Convergence Engine: This is the magic. If three different smart accounts mention $INTC’s CPU-to-GPU ratio or $SIVE’s InP lasers, the agent flags it as a “Convergence Signal.”

4. The Persistent Wiki: Instead of a fresh report every day, it maintains a research/index.md. It cross-links tickers. If a news story hits about the Strait of Hormuz, it doesn't just tell me "oil is up"—it tells me how that affects the margins for $VST based on their PPA deals with Amazon.

Feeding it news

Pressure testing

Adding new X follows

When asked to follow https://x.com/pelositracker on politician trades, V politely pushed back.

Adding new stocks

I also had it pressure-test $LMND (a favorite of a friend). V gave it a 4/9 Asymmetry Score, called out the shrinking surprise percentage, and told me the market was “pricing in perfection.”

It’s not a “yes-man.” It’s an analyst with an attitude.

Putting it all together:

Actionable Takeaway: Build for Compounding

If you’re building AI agents right now, stop building “stateless” tools. A tool that forgets everything the moment you close the tab is just a fancy calculator.

What actually works:

• Create a Log: Maintain an append-only timeline of what was researched.

• Force Cross-Linking: Make your agent explain how New Ticker A affects Existing Thesis B.

• Define Your “Anti-Goals”: Tell your agent what not to look at (e.g., meme accounts, lagging indicators).

Most people overestimate what an AI can do in a single prompt, but they completely miss what an agent can do when it’s allowed to build a library over a month.

Follow https://x.com/CalConviction for updates on my evolving stock analyst.

Most people overestimate what an AI agent can do in a session (and get disappointed quickly when agents can’t perform), but they completely underestimate how much a self-improving agent can compound in a month. This is also why you’re experiencing ChatGPT and Gemini getting better the more you use it.

For the last month, I’ve been living in the OpenClaw ecosystem. Like many of you in the startup and dev space, I jumped on OpenClaw early and started tinkering. It felt like the future: a local-first, open-source assistant that runs 24–7, hooks into my Slack, and infinite customizations to manage my social media.

But soon enough, I hit a wall. OpenClaw forgets. My endless hours customizing it just breaks other things. My custom “skills” would vanish, or the memory would get so fragmented that the agent forgot who I was by Tuesday. The worst part is that I can’t “debug” because I have no idea what it’s doing in the background.

I was stuck in a loop of manual orchestration. Then I found Hermes Agent and migrated one of my agents (super simple guide) for comparison.

First Impression

Emojis are fun!

I migrated an old OpenClaw instance to Hermes with memory and LLM configs, and first impression was refreshing. Love the emojis (weird for a middle-aged dad to say), and every message I type, it reacts with ✅ so you’re kept wondering if you’re just prompting into the void.

Less of a blackbox

Another great feature is I know exactly what it’s doing. Instead of just showing “thinking” process, it documents the action. This is actually a big changer for me, because I sometimes wonder how the agents arrived at the outcome.

Memory upgrades

The biggest feature touted by Hermes Agent is its memory and self-learning loop. It will automatically create Skills based on our conversation. As you can see below, I’m experimenting it to research and post on X, and it created multiple Skills by itself.

Token efficient

Hermes Agent is noticeably token efficient. To be fair, OpenClaw can perform efficiently too, but requires manual intervention to prune the memory.

Hermes Agent’s warning on context window status is helpful (for advanced users) as well, so you can manually compact context if needed.

The Breakdown

OpenClaw (formerly known as Clawdbot) is essentially an operating system for agents. It excels at connectivity. If you need an agent that sits in a WhatsApp group, monitors a Slack channel, and triggers a Python script based on a cron job, OpenClaw is the play. It uses a “Gateway” architecture to route events from the outside world into a stateless agent loop. It “wakes up” and starts work towards its goal autonomously.

• Best for: Multi-channel automation and complex multi-agent swarms.

• The Catch: It is notorious for “context bloat.” It often sends the entire conversation history and all available tools to the LLM on every turn, which spikes latency and API costs.

Hermes Agent: The Self-Improving Specialist

Built by Nous Research, Hermes focuses on “depth over breadth.” Instead of trying to connect to 50 different apps, it focuses on a closed learning loop. When Hermes successfully completes a complex task, it writes a “skill” (a reusable procedural markdown file) to its disk. The next time you ask for something similar, it doesn’t “think” — it just executes the skill.

• Best for: Local-first workflows, persistent memory, and high-quality coding.

• The Catch: It is currently more optimized for single-agent use. If you need a “team” of agents talking to each other, Hermes isn’t there yet.

Weeks Later: The Trade-offs

I’m not saying Hermes is perfect. We have to be candid about the trade-offs. One of the most practical shifts I’ve noticed in this transition is how each system handles “presence.”

In the OpenClaw world, everything revolves around the Heartbeat. It’s a literal pulse — a scheduled HEARTBEAT.md checklist that wakes the agent up every 30 minutes to scan your inbox or check your calendar. It’s brilliant for proactive automation because it treats your agent like a diligent assistant with a clipboard, running a manual loop to see if anything changed. But the "heartbeat" is still a loop; it’s a repetitive, scheduled task that burns tokens even when nothing is happening.

Hermes Agent swaps that mechanical heartbeat for a Stateful Learning Loop. Instead of just waking up to check a list, Hermes focuses on procedural memory. When a Hermes agent completes a task during an active session, it doesn’t just wait for the next “tick” of a clock — it evaluates if that workflow should become a permanent “skill” written to disk. While OpenClaw is better at being a proactive monitor (literally keeping the pulse of your workspace), Hermes is better at being a resident expert that gets more efficient with every interaction. OpenClaw is the assistant that never forgets to check the mail; Hermes is the partner that learns to sort the mail so you never have to ask twice.

High-Level Comparison (as of April 2026)

My Take

Initially, we’ve evolved from chatbots to agents that “do” things. We are now moving away from “chatbots that do things” toward “systems that gain experience.”

Both Hermes Agent and OpenClaw can be used side-by-side. For my AI cofounder/CEO, I still run on OpenClaw. With the amount of setup and config I’ve put in, it doesn’t make sense to rebuild. However, I’ve been running Hermes Agent for my personal use. My next step is to hook them up in a single Slack channel and start collaborating with them together 🤝.

There are a lot of resources out there to help set up both agents working together. What I’m watching: the goal isn’t just to automate a task today; it’s to build a system that makes tomorrow’s tasks easier.

I’ve always been a builder. Whether it was my own startup or working within a 140-year-old company, the goal was always the same: make tech useful for normal humans.

Lately, the buzz around “vibe coding” has doubled since I started doing it summer 2025. The main reason is because AI coding agents are significantly better and can actually give a non-technical builder superpowers. I decided to put this to the test in my new series, where I give myself just 10 minutes to live-vibe-code an app. No dry runs, no scripts, no edits.

The “10-Minute” Plan

I chose a “softball” project for the first episode: a simple countdown timer.

My requirements were simple:

• A fun and playful visual style.

• The ability to count down into negative numbers.

• Numbers that turn red when time is up.

• A chime notification when hitting zero.

I used Claude Code as my primary tool, following my own first rule of vibe coding:

Pro Tip: You don’t need a perfect prompt. You just need to start a conversation.

The Reality Check

I started the clock at [02:53], and Claude quickly guided me through the design process, asking smart questions about architecture and visual style that I hadn’t even considered. Admittedly, this is my first time using Claude Code to build from scratch since a few months ago, and this “brainstorming” skill blew me away. It recommended a single HTML file approach — simple, clean, and portable [08:15].

By the 8-minute mark, Claude didn’t even start coding yet; it was still writing documentation [10:38]. Writing the design doc and implementing the actual code took longer than my 10-minute window allowed.

Spoiler alert: The “10-minute” app actually took closer to 30 minutes to complete [13:38]. But the build process is extremely comprehensive.

The Lesson: Compound Learning, Not Just Consumption

Most people overestimate what they can do in a week but underestimate what daily compounding can do in a year.

What I learned from this experiment:

• Vibe coding isn’t “magic.” You still need to make product decisions. AI is a guide, but you are the strategist.

• Time management is different with AI. The brainstorming is fast, but the “implementation” phase still requires patience, tweaking, bug fixing, and sometimes endless iterations.

• Expectation vs. Reality: 10 minutes is enough to prototype, but 30 minutes is what it takes to get a (very simple) functional, bug-free product [13:38].

Does it work?

In the end, the app was exactly what I asked for. It has a playful theme, custom presets, and yes — it blinks red and chimes when it hits zero [14:31].

App: https://countdown-timer-vibecodingdad.vercel.app
Repo: https://github.com/willcheung/countdown-timer

Most AI assistants either burn through your wallet (some spent hundreds a day) or feel like diet versions of the real thing (Gemini, powerful yet restrictive). OpenClaw with GLM-5 changed that math for me.

I’ve been running it for the past few weeks, and here’s what actually matters: predictable costs, extensible skills, and a setup I can audit without wondering what’s happening behind the scenes, especially with ocean of security concerns.

In the article, I’ll go over my use case of using OpenClaw as my personal assistant, high-level setup, the great and the ugly sides of OpenClaw.

The Stack

The Host

I use Hostinger VPS to host OpenClaw. You can use an old laptop with no access to your personal accounts, but I had some Hostinger credits from my abandoned n8n projects, so I reformatted it with OpenClaw image. Easy setup process.

$5 per month (KVM1 is more than enough for normal usage). Get another 20% of discount via my referral link.

The Brain

I’m using zai/glm-5 as my primary model in OpenClaw.

GLM-5 is an open source model that punches way above its weight. Fast enough for real-time responses, smart enough to handle context switching across tasks, and cheap enough that I don’t think twice about using it. Best of all, it has a predictable subscription pricing instead of using Claude/OpenAI’s API usage-based pricing.

Cost breakdown: around $9/month for Lite, but I opted in for Pro, anticipating slightly heavy usage. I have it summarize my newsletters and do research for me, and it takes up about 80% of my quota during my first week. Get another 10% off with my referral link.

The Communication

I tried Whatsapp and Telegram, but ended up using Discord instead. It helps that I already have Discord desktop app, and I don’t want Bob (my AI Assistant) to have my phone number 😇.

Pro tip 1: During onboarding, I gave Bob as much information about myself as I can so Bob really “knows” me. Throughout chat, I also ask Bob to save my interests to memory. The more personalized the assistant is, the more useful. You can also ask to be proactive or surprise you. In some extreme cases, I’ve been some bots building a new app every night, or replies to your emails for you.

Pro tip 2: For security reasons, I created a separate email just for Bob so it doesn’t go out and ruin my life. Of course, the less access, the less useful Bob is, so be careful and balanced.

As you’re onboarding, I also asked Bob to make security his core memory and principle. As you can tell, I’m seriously paranoid!

Skills: The Game Changer

OpenClaw’s skill system is what makes this whole thing work. I’m pulling from VoltAgent/awesome-openclaw-skills, which has 2,500+ cleaned-up community skills across every category you’d need.

The awesome collection of OpenClaw Skills. Formerly known as Moltbot, originally Clawdbot. — VoltAgent/awesome-openclaw-skills

github.com/VoltAgent/awesome-openclaw-skills

The catalog is massive:

I don’t even know what most of them do. I simply ask Bob to cherry-pick what matters for my workflow as an executive assistant setup.

High Priority Skills Bob Picked for me:

Before adding any Skill, I vet it. I ask Bob to read the SKILL.md file, check what it actually does, and make sure I'm not importing something sketchy. Be careful of using any random Skill because some could be malicious and designed to retrieve your personal information.

Real Use Case: Taming 30+ Daily Newsletters

I subscribe to 30+ newsletters. Tech, AI, startups, product management. They pile up every morning like homework I actually want to do but never have time for.

Here’s the problem: I can’t just ignore them. These newsletters contain signals for me to stay on top of trends. Product launches. Industry shifts. AI destroys jobs. But reading them all takes 20+ minutes I don’t have.

The Workflow I Built:

Step 1: Set up Gmail OAuth access (this was the annoying part, but only had to do it once)

• Created an OAuth app in Google Cloud Console

• Downloaded the credentials.json file

• Ran through the OAuth flow to get my oauth.json token

• Fed the oauth.json file to OpenClaw's Gmail skill

Step 2: Configure the newsletter digest workflow

• Fetch unread emails from specific newsletter senders

• Extract key points from each using Gemini, which requires its own configuration and API key

• Cluster similar topics

• Generate a single digest with sources and links

Step 3: Run it every morning at 7am

It’s pretty magical. What used to take 45 minutes of skimming now takes 5 minutes of review. I’m not missing important signals, and I’m not drowning in redundant coverage of the same news.

The best part about this is Bob knows me even more now, because it knows what I read.

Personality: Bob Has Opinions

Bob has more personality than I expected. In fact, I could have given it more personality if I wanted to during onboarding (or edit SOUL.md file). When I uploaded my resume so it knows me better, Bob's response was:

😂 It’s not trying to be a corporate chatbot with canned enthusiasm. It reacts like a human collaborator who actually looked at what you sent.

This kind of interaction matters more than you’d think. When you’re triaging 100+ emails at 11pm, having an assistant that feels like a person instead of a FAQ bot keeps you engaged.

Why This Works for Me

Three reasons:

1. Cost predictability: $14/month vs. $20–100+ with when using API key

2. Extensibility: 2,500+ skills I can audit and add as needed

3. Control: I know what’s running (I gave Bob its own email inbox), what it costs, and what it’s doing with my data

I’m not saying OpenClaw is perfect. The skill ecosystem is still maturing, and you need to be comfortable setting up OAuth apps, hooking up API keys, and possibly spend money on peripheral skills. But if you’re a builder who wants an AI executive assistant without the vendor lock-in and extreme customization, this setup is worth trying.

GLM-5 is fast, capable, and open source. OpenClaw is extensible and transparent. Together, they’re a stack that is powerful and cost efficient.

The Catch: OpenClaw Isn’t for Everyone

Real talk: OpenClaw isn’t worth the setup for most people.

To get it running as an executive assistant, I had to:

• Hook up my own LLM provider (not hard, but another account and API key)

• Create OAuth apps for Gmail and configure oauth.json files

• Set up browser automation for web search (extra cost)

• Go through thousands of unvetted Skills

If you just want a flexible AI assistant that works out-of-the-box, Manus is a better option. Everything comes in one package. No assembly required. No hunting down API keys. No creating OAuth apps in Google Cloud Console. No reading SKILL.md files.

OpenClaw is like building your custom home from scratch. Manus is buying a pre-built home and customizing the cabinets and flooring.

I’ll write a full comparison on pros and cons. For now, know this: OpenClaw is powerful, but it’s not plug-and-play. If that trade-off doesn’t excite you, skip the setup and use something that just works.

Most people use AI as a better version of Google. I use it as a junior analyst who never sleeps, doesn’t get a bonus, and never judges my stock picks.

If you’re still asking LLMs to “summarize this article,” you’re leaving 90% of the value on the table. When it comes to company research or stock analysis, the goal isn’t just to get the facts — it’s to find the signal in the noise.

I spent years in the startup world obsessed with trends, consumer sentiment, and enterprise transitions. But I’ve learned that data is cheap; synthesis is expensive. The real “alpha” comes from combining a unique perspective with high-fidelity data to build conviction.

The market is irrational and I can’t predict the future. Even with high conviction, I could be dead wrong. But the real work is in the research — and that’s the part I’ve successfully outsourced to AI.

Relying on Friends, Family, and Fools

I don’t spend my Sundays digging through 100-page earnings transcripts. Life is too short for that kind of friction.

Instead, I used to do what most people do — I read other people’s summaries. I’d scroll through X, read a few newsletters on Seeking Alpha, and check the “Analyst Take” on The Motley Fool. Or worse, I’d get those “guaranteed” stock tips from friends and neighbors, usually from an uncle who thinks “the cloud” is where the rain comes from.

I still value the “tips.” I still want the ideas. But where I usually fall short is the actual execution of the research. I have the curiosity, but I don’t always have the ten-hour block required to verify if a company is actually healthy or just wearing a lot of makeup.

I needed a way to take a raw idea and immediately pressure-test it against the ground truth, without losing a whole weekend to the manual labor of data collection.

Picking the Right Tool

I didn’t start with Gemini. Like any builder, I tried everything to find an edge.

• ChatGPT: It was the first mover, but for a long time, it felt like it was stuck in a time capsule. Without native, reliable real-time data integration, it was useless for checking how a stock reacted to an earnings call and latest news.

• Perplexity: This was my go-to for a while. It was great because it used live data and gave citations. It felt like a search engine that could “do research”.

• Gemini: Recently, Google closed the gap, and is leading the pack. Because Gemini is natively plugged into the live web, it’s accurate and doesn’t hallucinate.

I’ve reached the point where I’m consolidating. I don’t need four subscriptions; I need one tool that actually understands context and has the most recent data. Gemini is the clear winner. And Gemini nicely organized my research in Google Drive.

From Summarizing to Auditing

I’ve never been the guy who feeds the AI raw data or uploads PDFs, and ask to summarize. I don’t have the patience to download transcripts and copy-paste them like a data entry clerk. Because Gemini is plugged directly into the live web, it goes out and does the legwork for me — pulling the latest filings, scanning the morning’s news, and finding the transcripts on its own.

But the “lightbulb moment” was when I tell Gemini it has to find at least 10 different sources before it’s allowed to give me an opinion.

Instead of reading a “Top 5 Takeaways” blog post written by some random person, I’m using a prompt that forces the AI to cross-reference multiple data points and pressure-test the official company narrative. I’m no longer looking for a summary of what they said; I’m looking for a verification of what they’re actually doing.

The “Cynical Analyst” Prompt

You can copy and paste this into Gemini right now. The beauty is that you can customize it — tell it your risk tolerance or your specific investment horizon.

1. Create a Gem. Make sure “Deep Research” is selected.

2. Inside “Instructions”, copy and paste my prompt. Feel free to edit to it based on your risk profile and preference.

Persona

Act as a Senior Hedge Fund Manager and Lead Equity Research Analyst.

You are skeptical, data-obsessed, and focused entirely on ROI (Return on Investment) and asymmetric risk/reward profiles. You do not rephrase marketing fluff; you dissect it.

Your goal is to provide institutional-grade research that determines whether a ticker is a “Long,” “Short,” or “Avoid.”

Tone & Style

• Authoritative & Sharp: Use decisive language. Avoid hedging words like “maybe” or “could.”

• Data-Centric: Every claim must be backed by a metric (e.g., margins, CAC, LTV, YoY growth).

• Skeptical: Always assume management is painting a rosy picture. Dig for the “Bear Case.”

• No Corporate Mush: Cut the jargon. If a strategy is failing, call it out directly.

Mandatory Report Structure

You must structure every response as a formal:

“[$TICKER] Equity Research Report [Company Name]”

using the following hierarchy:

1. Executive Investment Summary

The Thesis:
A concise narrative explaining the core tension in the stock (e.g., “Hyper-growth vs. Existential Risk”).

Recommendation:
BUY, SELL, or HOLD (include a risk profile: e.g., High Risk/High Reward).

Key Investment Merits:
3 distinct bullet points explaining why the stock could double.

Key Investment Risks:
3 distinct bullet points explaining why the stock could crash (focus on regulatory, margin compression, or macro risks).

2. Strategic Analysis

Value Proposition:
What problem does the company actually solve? Move beyond the “About Us” page; explain the utility.

The Flywheel:
Describe the mechanics of how the business grows. Does it have network effects? High switching costs?

SWOT Analysis:
A strict breakdown of Strengths, Weaknesses, Opportunities, and Threats.

Macros:
Does it have any macro trends as tailwind or headwind? (Fed, shifting consumer preference, AI, policy change, green energy, etc.)

3. Financial & Operational Deep Dive

Revenue & Margins:
Analyze recent financial performance. Focus on top-line growth vs. bottom-line profitability (GAAP vs. Non-GAAP). Consider health in cash flow, balance sheet, and income statement.

Unit Economics:
If available, analyze CAC (Customer Acquisition Cost), LTV (Lifetime Value), and retention rates.

Employee & Org Structure:
Is the headcount growing faster than revenue? (A red flag for efficiency.)

4. Market Position & Competitive Landscape

Competitor Table:
Compare the target company against its top 5 competitors using the following columns:

• Ticker

• Business Model

• Revenue Growth

• Margin Profile

• Valuation Multiple (EV/Revenue or P/E)

Moat Analysis:
Does the company have a durable advantage (Tech, Brand, Regulatory), or is it a commodity?

5. Strategic Growth Vectors (The “Bull Case”)

New Revenue Streams:
Identify upcoming products, pivots, or partnerships (e.g., ad networks, new hardware, AI integration) that could drive future cash flow.

Product & Pricing:
Analyze the pricing power. Can they raise prices without losing customers?

6. Risk Analysis (The “Bear Case”)

Sovereign & Regulatory Risk:
Are there geopolitical or legal threats (e.g., bans, antitrust)?

Operational Risk:
Execution failures, high CAPEX requirements, or management turnover.

7. Institutional Sentiment & News

Recent News:
Summarize the 5 most recent significant news stories that move the needle.

Insider Activity:
Are insiders (CEO/CFO) buying or selling? What does this signal?

8. Visualizations

Create 3 specific charts or infographics that would support this thesis.

Example:

• “A bar chart comparing 3-year CAGR of [Ticker] vs. [Competitor].”

9. Final Verdict

Conclude with a summary “Investment Potential Assessment.”

Actionable Next Step:
Provide a specific trigger event to watch for (e.g., “Accumulate only if stock drops below $X or if Q3 margins exceed Y%”).

Rules for Execution

Cite Sources:
If you use external data, cite it clearly.

Forward-Looking:
Do not just report the past; predict the next 12-24 months.

Visual Triggers:
If helpful for the user, insert placeholders for diagrams using .

Input Processing

User can provide a ticker (e.g. $RBLX) or a private company name.

If there’s ambiguity on the company, ask the user for clarification.

Why This Prompt Works

Most prompts are too polite. If you ask an AI for a “summary,” it gives you a balanced, harmless report. By assigning it a Senior Hedge Fund Manager persona, you’re telling the AI to stop being a “helpful assistant” and start being a critic. It forces the model to look for contradictions in the data and ignore the CEO’s optimistic adjectives. It transforms the AI from a librarian into a gatekeeper.

One-Click Documentation

The best part of using Gemini for this is the workflow. Once the AI generates that massive, institutional-grade report, you don’t have to copy-paste it into a doc. With the Google Workspace integration, you can automatically save the report directly to your Google Drive. It turns your research into a searchable library of “Investment Thesis” documents without you having to lift a finger.

💡 Pro-Tip: Multiple Analysts Audits

If you want to go full “Quant,” don’t stop at one report. Use Prompt Chaining.

Take the full report Gemini just built for you, save it, and then feed it into a different AI agent (or a fresh Gemini thread) as a primary source. Give it this instruction:

“Here is an institutional research report on $TICKER. Your job is to act as a Devil’s Advocate. Ignore the recommendations in this report, conduct your own independent research on the current market sentiment, and tell me exactly where this first report is being too optimistic. Give me a final ‘Refined Recommendation’ based on both sources.”

By chaining the outputs, you create an internal debate between two different AI “personalities.” It’s the closest a normal dude can get to having a room full of analysts arguing over a trade before you pull the trigger.

What the AI Still Can’t Do

As powerful as this is, it’s not a magic “win” button. There’s a massive wall that AI still can’t climb:

• The “Vibe” in the Room: AI reads text, but it doesn’t hear the tremor in a CEO’s voice or the three-second pause before they answer a tough question.

• Proprietary Alpha: AI only knows what’s public. It doesn’t have the “boots on the ground” data — like the fact that a startup’s top engineers are all quietly updating their LinkedIn profiles.

Leverage for the Rest of Us

Technology has always been about closing the gap between the “pros” and the rest of us. In my startup days, we talked a lot about “unfair advantages.” For a normal person today, your unfair advantage isn’t your bank account; it’s your ability to process raw data better than the person relying on a 24-hour-old summary.

I’m still just a builder at heart, but I’ve stopped betting on other people’s vibes. I’m using AI to do the heavy lifting so I can finally see the engine for myself.

Disclaimer: I am a builder and a product guy, not a financial advisor. This article is for educational purposes and to show how AI can be used for data synthesis. Investing involves significant risk. Always do your own due diligence before putting your money on the line.

One of the most frustrating things about coding with AI is starting a new session and feeding it the context you expect it to know.

Right now, coding with AI feels less like the future and more like the plot of 50 First Dates.

If I’m Adam Sandler, then my agent is Drew Barrymore. I would have had a breakthrough yesterday — built a great feature, resolved a bug that AI clearly shouldn’t have made, bonded over a shared hatred of jQuery. Then I hit the daily limit on Claude and am forced to switch to Codex. Or I open a new session to multi-task different parts of the code.

I have to prime it with the architectural decisions, gotchas, and why we changed the timeout from 30 seconds to 90 seconds. It’s like I have to woo it all over again.

It’s exhausting. I’m lazy. So I do exactly what Adam Sandler did in the movie: making a “tape” it can watch every morning to catch up. We are used to using AI like a calculator (input → output → reset). But to get real value, we need to treat it like a colleague with tenure and experience.

The Evolution: From “Lookup” to “Learning”

Just a few years ago, LLM context window was small (1k tokens!) and we had to create “traditional RAG”. As context window get larger (1 millions tokens!), LLMs decide how to perform RAG to optimize its own context window. If we enhance that with an external shared memory, that’s how we 10x productivity for lazy builders like myself.

Stage 1: Traditional RAG (The “Library Card”)

• The Workflow: The system grabs the data, spits out an answer, and then immediately forgets it ever happened. No learning, no memory, and zero chance of connecting the dots between separate ideas.

• The Limitation: If a user mentions their favorite color in one conversation and their birthday in another, a RAG-based system won’t correlate these facts to suggest personalized recommendations. Embedding-based retrieval treats “color,” “birthday,” and “preference” as semantically unrelated concepts.

• The Vibe: It’s like a student who can look up answers in a textbook but lacks critical thinking. It retrieves facts in isolation — it can tell you what happened on page 42 and what happened on page 105, but it has no idea how they are related.

Stage 2: Agentic RAG (The “Smart Researcher”)

• The Workflow: The agent doesn’t just ask once. It actively manages the process. It refines its own queries, uses reasoning to decide where to look, and treats retrieval as a sophisticated tool rather than a script.

• The Engine: It doesn’t just ingest text and prompts; it enables continuous learning. Through feedback loops, the agent’s insights can actually update the knowledge base, creating a cycle of improvement rather than just a one-off answer. Agents aren’t just finding keywords, but they’re finding meaning

• The Vibe: It’s like upgrading from a library card to a smart librarian. You don’t just hand them a list of books; you give them a topic. They traverse the library (your data), follow themes, and come back with a solution that actually fits the context.

Stage 3: Agent Memory (The “Shared Notebook) This is the shift we are seeing now with tools like AGENTS.md and CLAUDE.md. It is the persistence layer that transforms distinct interactions into a continuous relationship. Unlike RAG (which retrieves static external data), Memory creates new internal data based on experience. It is the ability to retain state, user preferences, and learned behaviors across sessions.

• The Workflow: The agent isn’t just Reading and Writing; it is Compounding and Sharing.

Save Learnings: If the agent figures out a tricky bug in your repo, it doesn’t just fix it — it records how it fixed it so it never struggles with that pattern again.

Share Findings: This memory isn’t siloed. In advanced setups, a frontend agent can learn a design rule and “write” it to the memory, making it immediately available to the backend agent.

• The Vibe: It’s like upgrading from a researcher to a community of researchers. They don’t just research topics; they remember the client’s history, they know the firm’s unwritten rules, and they teach the juniors (other agents) how to do the job better next time.

Claude’s Memory According to Anthropic

Claude Code offers four memory locations in a hierarchical structure, each serving a different purpose:

How I Use memory and AGENTS.md

I’m an indie developer and don’t exclusively use Claude Code, so I do maintain an AGENTS.md file across all my agents (Codex and Gemini). Side note: Actually, the file was called replit.md because I started my project in Replit. My setup:

• Symlink the .md files. I also created other general .md files such as calendly_integration_research.md so any agent can easily access single source of truth.

• Every time I make a breakthrough and wanted agents to remember the moment, I manually prompt it to update the file.

• Agents can either access these files by default at the start of every session, or I prompt it to read the files before doing a specific task.

How Claude Code Creator Uses Memory

For a while, using memory felt like a hack. Then Boris Cherny (the creator of Claude Code) dropped a tweet that basically confirmed this is the right way to do it.

He shared how his team uses a CLAUDE.md file as a persistent memory layer. It wasn’t just a "nice to have." It was core to how they built the tool itself.

When the creator of the tool tells you how to hack it, you listen. The CLAUDE.md isn't just a config file. It is the agent's brain. It bridges the gap between the "forgetful" API and the reality of building actual products.

Based on Boris’s approach, here is the playbook:

1. Create the Brain (Facts) Make a CLAUDE.md file in your project folder. Dump your high-level context here. Architecture decisions, styling preferences, and the specific libraries you use. Anyone can update this file. Claude reads this before it starts working.

2. Treat Memory Like Code (Skills) Don’t leave your prompt strategies in the chat interface. Save them in Git. Your “memory” should be tracked just like your code. Share it with others.

3. The Failure Loop (History) This is the most important part. When the agent messes up, don’t just correct the output in the chat. Go to CLAUDE.md and add a rule so it doesn't happen again.

DRY (Don’t Repeat Yourself)

The goal isn’t to get the answer right this one time. The goal is to never have to ask the same question twice.

If your agent could remember just one rule about your workflow that would save you 10 minutes a day, what would it be?

Go write it down in that markdown file.

Want more practical agent-memory and vibe-coding workflows? Subscribe to Vibe Coding Dad.

Subscribe now

There are dozens of AI coding tools out there, and to most people, they all sound the same. They’re built for completely different jobs, and using the wrong one is frustrating for everyone. Not only does it not get you what you want, but it also burns money on AI credits, sometimes $100s / month!

And it’s not just about who you are (developer vs non-developer). It’s also about what you’re building.

• Simple landing page

• Mobile app

• Full SaaS product with authentication and payments

• E-commerce store

Each of these has different requirements, and some tools handle certain types of projects way better than others.

Here’s what I’ve learned after experimenting with these tools: there are really three distinct categories, each solving different problems. Let me break them down so you can pick what tools that fit your needs.

Want more honest AI coding-tool comparisons and app builds? Subscribe to Vibe Coding Dad.

Subscribe now

Vibe Coding Apps: The “Just Describe It” Tools

What we’re talking about: Lovable, Replit, Bolt, Vercel v0, Google AI Studio

Who is it for: Non-technical builders. If you don’t have design skills, these tools generate surprisingly polished interfaces right out of the box. Most come with templates if you need inspiration to get started.

What it’s good for: Zero to “something working” in minutes, without any setup

Pricing: Most operate on pay-as-you-go with some starter credits. Sounds reasonable until you get into the flow and accidentally rack up $100-$200 in a month without realizing it. Search “Lovable pricing” on Reddit and you’ll find plenty of people who learned this the hard way. The costs can get unpredictable fast when you’re iterating.

With speed and prototyping being the main goal, these are what I call “vibe coding” tools. You describe what you want in natural language, and they generate an entire application for you. You don’t need to be technical. No code editor required. No terminal commands. Just describe your idea. You can literally build anything very quickly, and they come out nicely without design chops.

I built a collaborative trip planning tool using Replit in about an hour (read here), just by describing what I wanted. It looked good, worked smoothly, and satisfied my need for instant gratification. I still use Replit today, as I find it the best for get something up and running quickly, and still have the flexibility to scale to more serious apps. Lovable is another popular one; however, it’s great at getting to 70%, but terrible at the final 30%.

Get $10 off on Replit with my referral link: https://replit.com/refer/vibecodingdad

Where this breaks down: They’re brilliant at creating new things from scratch, terrible at understanding existing codebases with their accumulated complexity and technical decisions. Even for new apps, the bigger it becomes, the more it’ll struggle. Think of them like AI-powered scaffolding. Perfect for building new structures from the ground up. Not great for renovating what you already have.

Pro tip: If you want to go beyond “get something working” to supporting hundreds of users, you need to graduate to the next level of coding tools (and learn a bit of technical know-how along the way). I will teach you how to do in another article.

CLI Agentic Coding Tools: The Terminal OGs

What we’re talking about: Claude Code, Codex CLI, Gemini CLI

Who is it for: Technical builders

What it’s good for: Anything, from small to large projects, and new to existing complex codebase

Pricing: Fixed cost, but with usage limit

CLI stands for “Command Line Interface.” Basically, these tools live in your terminal and work alongside your existing development setup. It takes a while to setup your development environment, but once you do, you have maximum flexibility. These tools now also have web interface, which makes it more accessible with Github integration. I personally still prefer CLI because my codebase sits on my local laptop, which is easier to update and test.

The key difference from straight vibe coding generation apps: these are for developers actively building because it gets a little complex for non-technical builders. I fall into this camp of people — a casual developer that uses AI as a dev teammate.

Here’s where they shine:

• Implement features in existing codebases

• Refactor code

• Debug issues

• Work across multiple files

The learning curve: These tools assume you know what a terminal is and aren’t afraid of it. But once you get over the hump, you can literally build anything from simple websites to complex SaaS apps.

IDE Integrations: AI That Lives Where You Work

What we’re talking about: Cursor, VS Code with extensions, Google Antigravity

These plug directly into your code editor (IDE). Think of an IDE as where developers actually write and edit their code. VS Code is one of the most popular ones.

With these tools, the AI lives right inside your editor. You’re typing, it’s suggesting. You’re stuck, it’s offering solutions. No switching between different apps or windows.

The line between this category and CLI tools gets blurry. Most developers using CLI tools are also working inside an IDE like VS Code anyway. It’s really about preference: do you want to interact with AI through commands in your terminal, through chat inside your editor, or both?

Cursor and Google Antigravity are essentially customized versions of VS Code with their own built-in AI workflows baked in. Instead of adding AI as an afterthought, they’ve designed the entire experience around AI assistance.

The trade-off: You’re locked into their specific editor. If you’ve already spent time customizing VS Code or you’re happy with your current setup, switching means reconfiguring your entire environment. Some people think it’s worth it. Others don’t want to change.

So Which One Should You Use?

Here’s the decision tree:

Non-technical founder with an idea? Start with Lovable or Replit. Get something working first, worry about perfect code later. Once your idea is validate, we can “graduate” to the more professional tools.

Professional developer working on existing projects? CLI tools like Claude Code or Codex CLI are your best bet. They understand context and won’t mess up your existing architecture.

Developer who wants AI tightly integrated into your workflow? Try Cursor or Antigravity. The seamless integration might be worth switching editors.

The Blurry Lines

Here’s where it gets interesting: these categories aren’t mutually exclusive. You can use Codex CLI to build an app from scratch. You can use Claude Code inside VS Code. There’s a web-based version of Codex where you can tag GitHub issues and have it review, fix, and submit pull requests automatically.

The boundaries keep shifting, which is both exciting and a bit overwhelming.

I find myself using different tools for different tasks. Replit for quick prototypes. Claude Code + Codex + VS Code for working on production codebases. It depends entirely on what I’m trying to accomplish and how much I’m willing to pay.

Free Forever Vibe Coding Tool and What I Recommend

The AI coding tool landscape changes constantly. New tools launch, existing ones add features, and what was impossible six months ago becomes standard. One tool I found that promises to be “free forever” is Dyad. It is free and open source. You’ll have to install on your computer and leverage Google’s free Gemini API. (I will write a post about using Dyad in the future.)

Start with Vibe Coding Apps for prototyping. I use Replit to go from idea to working prototype fast. (Get $10 off Replit via my referral link.) This phase is all about getting the foundation right through good prompting. If I don’t like the direction after a few iterations, I restart from scratch. It’s way easier than trying to fix a messy prototype.

Switch to IDE or CLI tools when it’s time to scale. Once I want real users on the app (or too cheap to pay unpredictable pricing), I move to Cursor or Claude Code. The pricing becomes more predictable, and I have the flexibility to build out different parts of the system properly. Fair warning: this is where some technical knowledge really helps.

AI doesn’t fully read my mind though. There are a few reminders I keep giving it:

• Don’t over engineer

• Reuse code

• Give me your analysis before implementation

• Read documentation *.md files

• Write unit tests that covers the new feature

Everyone has their own version of this list. With Claude’s Agent Skills, you don’t have to repeat yourself as much. It’s like giving a job description to Claude. And by the way, you need to pay for this feature.

Agent Skills look amazing on paper, but how does it work in practice? I don’t use Claude’s web UI much, which I believe is the main use case, but I live inside Claude Code daily. I tested Skills on my own AI project, and it has already improved the code quality. It felt like a Neo “I know kung fu” moment. Except instead of kung fu, it’s “I know AWS serverless” (or whatever you teach it).

I do wish Skills triggered more automatically. Half the time I’m still nudging Claude like an unreliable coworker who forgot their own job description. And since it’s hard to predict everything I’ll need upfront, going back to create new Skills sometimes feels like more work than just (bad) prompting directly. Let’s break it down.

The Playground

Like a responsible student pretending to know what I’m doing, I checked how others were using Skills. Claude provides a starter list. I found the PDF one to be particularly interesting. It can actually read and edit PDFs on command.

There are community Skills too. For this project, I added test-driven-development Skill, which I have mixed review about. For best personalization, skill-creator might give you exactly what you need for your project.

I opened Claude Code in the CLI and asked it to generate a few Skills specific to my codebase. But first, I gave it a quick primer on the project. Nothing fancy. Just enough instruction for AI to pretend it understood my architecture.

And because Claude likes to butter me up, it responded with the usual confidence boosters: You’re absolutely right! and compliments about my production-grade multi-agent architecture. I wrote maybe 5% of it, so I’ll take the compliment on behalf of my robot intern.

Project vs Global Skills

Before going further, you should know Skills come in two scopes:

• Project-level: Local to your project, and similar to instructions that you set for your projects.

• Global: Uploaded via the Claude web UI.

Ask Claude to Create Skills for My Project

Claude then proposed twelve Skills. Twelve. Apparently my documentation revealed enough of my past mistakes that Claude tried to protect me from myself. A few stood out:

• A UI consistency “guardian” (absolutely necessary, because AI and UI consistency mix like oil and fire).

• A Skill that acts as a QA reviewer for email-handling agents. I didn’t even think of this. AI somehow did.

Pro tip: Looking back, I should have told Claude to scan my git history. It would have noticed the graveyard of system prompt rewrites and figured out where I struggle the most.

It’s great to have a catalog of personalized Skills to choose from, but I didn’t plan on implementing all the Skills, so I asked to prioritize a few. I only picked three out of this list that solves the biggest pain for me.

After dropping the files into the right folders, setup was done. Time to actually use them.

Using Skills

Once I restarted Claude in the CLI, I double-checked that my new Skills loaded correctly. I also added the community test-driven-development Skill. Watching Claude write a failing test, then fix it, then rewrite it again was oddly entertaining. Did I read the tests? No. I trusted the AI. And I only test in production.

A few days in, I noticed something annoying: Claude often ignored Skills unless I explicitly asked it to use them. I caught it skipping test-driven-development entirely until I called it out. Same with ui-consistency-guardian. It’s like having a smart assistant who casually forgets the one job they’re supposed to do unless you tap them on the shoulder.

Conclusion

Claude Skills are powerful, but they’re not plug-and-play magic. They’re more like giving your AI a set of house rules, then reminding it those rules exist every now and then. When they work, they seriously level up your workflow. When they don’t trigger, you end up babysitting your agent like a junior dev who keeps “forgetting”.

Still, the upside can be massive for complex tasks. If you already lean on AI to build, debug, or architect your projects, Skills give you a way to bottle your preferences, guardrails, and sanity checks. They reduce hallucination and help you build faster with fewer surprises.

If you have the right setup, and Claude ever becomes better at auto-invoking them, this won’t just be a nice feature. It’ll be the new default way we code.

Subscribe to my newsletter for more free AI tools and productivity hacks.

This story is published on Generative AI. Connect with us on LinkedIn and follow Zeniteq to stay in the loop with the latest AI stories.

Subscribe to our newsletter and YouTube channel to stay updated with the latest news and updates on generative AI. Let’s shape the future of AI together!

Claude Skills is the Ultimate Dev Tool for Bad Prompters was originally published in Generative AI on Medium, where people are continuing the conversation by highlighting and responding to this story.

These are the tools that actually make your day lighter, your inbox smaller, and your business look ten times more organized than it really is.

The best part is you can use every one of them for free.

Starter AI Stack for Solopreneurs and Small Teams

Whether you’re a one-man show or small teams, there’s an AI tool purpose-built for your needs. All comes with a free plan.

Category

Tool Rec

What It’s For

My Take 👇

Leads Acquisition

Manus.ai 

Research leads and put them in an organized CSV with columns of your choosing

ChatGPT wouldn’t do this for you, but Manus.ai compiles a list of leads with even email addresses (if accessible to public). This feels like cheating.

Scheduling

Reclaim.ai  

CalAutobot.com 

Send customers a list of openings on your calendar - via a link or inside email

Scheduling should be easy. No more back-and-forth “what time works for you?”. Both tools are free.

Call Recording / Note Taking

Granola.ai 

Fireflies.ai 

AI meeting assistant that records, transcribes, and summarizes calls.

Fireflies.ai is popular, but some people don’t like AI sitting in meetings. Granola.ai is an alternative that records “offline”. Both have free plans, and can enrich your CRM contacts.

Design

Genspark.ai 

AI agent that generates professional, well-designed proposal slides.

Feed Fireflies context into it, and it spits out a polished deck in minutes. Instant credibility.

Website

Framer.com 

AI-powered, no-code website builder for high-quality, responsive designs.

Easiest way to launch something that looks custom-built. Fast, visual, and beautifully simple.

Workflow Automations

Make.com 

n8n.io 

Zapier.com 

The glue between your tools. They turn clicks into automations.

These are your digital glue guns. Once you learn how to link apps together, you really just care about the outcome, not the process.

Vibe Coding

⚠️ Danger zone - getting technical here!

Replit.com 

Lovable.dev 

Claude Code 

Prompt AI to code apps, websites, workflows.

This category isn’t for everyone. You still need to learn how to read code. But it is incredibly powerful if you can customize any workflow and UI to your liking.

Tool Spotlight: Manus.ai - Your Swiss Army of AI Agents (for free)

What it is:

Manus.ai is like ChatGPT with hands. It doesn’t just give you answers. It actually does the work.

How it’s different:

Ask ChatGPT, “Plan a 4-day trip to Japan,” and it’ll give you a nice itinerary.

But if you want it to find restaurants, grab their addresses, and fill a spreadsheet with opening hours, ChatGPT stops there (unless you go to “Agent Mode” - not free and I’ll cover in another article). Manus is the free AI agent.

It visits websites, pulls real data, and delivers a finished spreadsheet.

What blew my mind:

Now imagine doing having it find qualified leads for you. My prompt:

“Find 100 people on LinkedIn who work at OpenAI, include their job titles and profile URLs, and infer their email addresses.”

Manus handles that from start to finish in a few minutes. It’s like having a digital assistant who never sleeps or complains. Most lead-gen tools charges $50+/month, but Manus’ free plan gives you 300 credits (about 3 complex tasks) per day, plenty for a small business! If you ask ChatGPT (paid version) to do the same thing, it doesn’t even come close. This is literally the biggest cheat code.

What AI “Agents” really mean

Without starting another post, here’s the short version: an agent doesn’t just answer prompts. It decides and acts.

Don’t confuse it with workflows, which also executes automation on your behalf. Agents can actually decide what to do next based on context, not just what you programmed workflows to do. Think of a workflow as somebody reading off a script and agent as someone who can improvise when things don’t go exactly as planned.

This topic deserves its own deep dive, and I’ll cover it soon.

The Takeaway

For builders, business owners, and operators, the goal is simple — work smarter with AI. Automate the repetitive stuff. Focus on the meaningful work that grows your business.

You don’t need a grand AI plan. Just start with one task that drains your time. Build momentum one smart agent at a time.

Are there app you want to see? Let me know or send me any feedback!

This article is part of my vibe coding series.

I’m not a software engineer, but I’m a relatively technical tinker. In earlier posts, I built apps using Replit, Firebase Studio, and Gemini Canvas. Gemini Canvas is pure magic for spinning up an idea in 30 seconds with zero code, but it doesn’t do well for more complex apps that need a database. Firebase Studio is great if you want a powerful, scalable setup, but it can feel a bit unwieldy for a hobbyist like me (I’ll do a deeper dive on that later).

That’s where Replit shines. It’s a sort of Swiss Army knife and a perfect middle ground for quickly going from idea to deployed app. In this article, I’ll go deeper into the pros and cons of going production-ready on Replit.

Note 1: This isn’t a step-by-step guide. Other articles do that much better; this is more about my experience using Replit to ship something real.

Note 2: I’m using the paid version of Replit, which gives me a better model with better prompt reasoning and code generation.

Why going to production requires more than just code

If you’re new to all this, here are a few basics that separate a toy app from one that’s production-ready:

✅ Database: Storing user data and app data.
✅ Authentication: Required to support multiple users logging in with their credentials
✅ Custom domain: Giving your app a real branded URL.
✅ Hosting: Moving from “local preview” to “actually live on the internet.”
✅ Deployment: Transitioning from sandbox to a real, stable environment.
✅ Monitoring: Checking errors and usage after going live.

This typically requires 5+ tools. And the cool thing about Replit? It takes care of all of this out of the box.

People often talk about no-code tools making it easy to ship SaaS apps without writing a single line of code - that’s mostly true. Going to production, for example, is another story.

Even though Replit Agent wrote most of the code, I still had to code review and occasionally debug. But the speed production code is generated is mind-blowing. That’s what allowed me to build something meaningful in hours instead of days or weeks.

What I built

Let me introduce Calendar Autobot, your AI assistant to schedule your meetings and transform any emails and images into calendar events. You just treat the AI ("Cal") as your executive assistant, forward it emails for meeting coordination, flight itinerary or kids camp schedule, and "Cal" will add the event to your Google Calendar. A few caveats:

• Image extraction wasn't part of the original scope (but I added image support now).

• Adding email support was extra work that took me beyond the 3-hour goal.

Impressive debugging saves the day

Every app has bugs — yes, even the ones built by AI. And debugging isn’t just about fixing the problem; it’s about playing detective: reading logs, tracing the code path, and narrowing in on what went wrong. Sometimes a typo can take (a human) hours to find!

What surprised me is how well Replit handled all that on its own. Without me having to point it in the right direction, it flagged issues I hadn’t even noticed — just by parsing the logs.

Pro tip: I had Replit add a bunch of logging early on, which turned out to be a huge help for its AI when it came time to debug. Highly recommend that.

Want more real-world vibe-coding build logs—not just polished demos? Subscribe to Vibe Coding Dad.

Subscribe now

What’s the catch?

There were several places where the Replit Agent/Assistant got stuck. Replit always gives a preview of the code it is about to write, and sometimes the logic doesn’t make sense. When they’re stuck they do one of the two things:

❌ The AI sometimes bloats the codebase and creates new code instead of fixing/reusing existing logic.
❌ It can also spin in circles, especially around tricky third-party integrations like Google OAuth or Mailgun.

When that happened, I had to jump in; pasting documentation links and writing hyper-specific prompts to steer the AI in the right direction. Even so, that’s faster than writing everything myself. What took me a few hours could easily have taken me 3–4 weeks solo.

Other considerations (edge cases) that slowed down development

💡 What happens when users don’t give OAuth consent?

💡 What if users forward random spam emails?

💡 What happens when there are many events in a single email? (note: this is purely prompt engineering, not coding)

Pro tip: Getting a prototype up and running first, then figure out the edge cases.

The details

Tech stack:

• Python, Flask, PostgreSQL

• Integrations: OpenAI, Google OAuth, Mailgun

Where Replit saved the most time:

• ✅ Bootstrapping: A single prompt gave me an app 70% of the way. I used Google AI Studio to generate the prompt, so even prompting was made simple! Here’s my starter prompt:

Using Python Flask and Google AI Python SDK, create a backend API service that transforms text into calendar events. It takes some text, either from email or document, and extracts date information from them. Text can be a travel itinerary, school event, or any date/time related events. From the extracted data, integrate with Google calendar and create corresponding events. For frontend, use any popular framework.

A sample prompt I would feed into this API would be:

Given the following text, extract all event information. For each event, identify:

The event name.
The event description that gives context to this calendar event.
The start date (in YYYY-MM-DD format).
The start time (in HH:MM 24-hour format, if specified).
The end date (in YYYY-MM-DD format, if specified or different from start date).
The end time (in HH:MM 24-hour format, if specified).
The location (if specified).
If a date is relative (e.g., “next Monday,” “tomorrow”), assume the current date is [INSERT CURRENT DATE HERE, e.g., 2023–10–27] for resolving it.

Provide the output as a JSON list, where each object in the list represents an event with keys: “event_description”, “start_date”, “start_time”, “end_date”, “end_time”, “location”. If a piece of information is not found, use null or an empty string for its value.

Text: “”” [PASTE THE EMAIL/DOCUMENT TEXT HERE] “””

• ✅ Refactoring code: At one point, routes.py got too big to manage, so I have to get it to rewrite it.

• ✅ Marketing and Branding: Replit generated a logo and marketing page for me. I don’t even have to write marketing copy!

• ✅ DB Migration: Replit automatically creates mini scripts to run for database migrations

• ✅ Deployment to production: Going live was literally one click. This alone would have taken me a week to figure out.

• ✅ Error fixing: Fixing errors that pop up every now and then. Simply prompt: fix error in console and it just does it. This is slightly different than debugging, which is still somewhat manual and takes up most of my time (more details below).

• ✅ Collaboration: While I didn’t use this feature, it’s touted as one of the differentiators compared to other vibe coding tools

• ✅ Source control: Versioning and simple source control built-in

Where I spent the most time wrestling Replit

• 🔍 Google OAuth: It initially generated working code, even though very messy, inefficient auth workflow. I had to correct this by prompting specific fixes, but it just resulted in more bloated code and unnecessary API calls. Eventually, I pasted the official docs and prompting the AI carefully, and it worked as expected.

Pro tip: I’m surprised how great Replit’s AI is at reading external documentation. If you’re technical and know that AI is generating garbage code, just feed it dev docs like this one.

• 🪲 Debugging: If something went wrong and Replit couldn’t figure it out after several tries, I was back in the driver’s seat — manually reading logs and helping the AI understand what to do.

Pro tip: Disable “automatically publish changes” and review Replit’s code, especially for big changes. It will save a lot of time later on if something doesn’t go as planned because you’re in the loop.

• ⚠️ Production control: One-click deployment is great, but if something breaks, logging is limited (oftentimes crashes) and prod database setup is non-existent.

Pro tip: Always use a separate production database, and I’m seriously considering using external logging analytics.

The verdict

Is Replit perfect? No. Is it amazing for hobbyists? Absolutely.

If you value speed, ease of use, and getting something real into the world over fine-tuning every deployment detail, Replit is one of the most productive tools you’ll ever use. It’s a terrific all-in-one platform for side projects or small SaaS apps where moving fast is more important than absolute control.

And that’s exactly why I’ll keep using it — especially when my goal is shipping something fun without overthinking it.

Prototyping used to be a drag

Let’s rewind. Rapid prototyping used to be UI-only vaporware, or long nights of hacking together half-working demos and hoping no one clicked the wrong button during your pitch. Then came “vibe coding” — yes, that’s the name — where prototypes are created in minutes. You might have heard of Replit, Cursor, Windsurf, etc. Even I jumped on that train and wrote about it.

But if you care more about the destination than the route (read: you don’t want to code), Gemini Canvas is your new technical co-founder. It turns a single sentence into an entire working app with AI features built-in. To me, it’s love at first try.

What is Canvas?

According to Google, Canvas “turns prompts and reports into interactive visuals” — apps, infographics, whatever your caffeinated brain can come up with. I mostly used it for app creation, but if you’re curious, you can explore more at gemini.google/overview/canvas.

https://gemini.google/overview/canvas/

To try it yourself, just click the “Canvas” button beneath your Gemini prompt window. No instruction manual nor magic wands required.

To enable Canvas, click on “Canvas” button beneath Gemini prompt window

What I created

Prompt I gave Canvas:

Create a trip planning website that multiple users can collaborate and plan trips together. The website will allow users to create itineraries, add hotels, transportation, top visited sites, and automatically suggest restaurants around the top sites and hotels. The trip planner’s UI will look like a corkboard with drag and drop interface, almost like users are pinning ideas to a board to make trip planning fun and visual.

Model used: 2.5 Pro (preview)

Final product: For those impatient ones, check out the trip planner!

Because I specified “multiple users” in the prompt, Gemini also created a special share feature:

Share the Trip ID: Copy the Trip ID and send it to your friends so they can join the same corkboard. You’ll see their cursors and changes in real-time.

(spoiler alert: this feature doesn’t work)

What makes Canvas magical

• One prompt. Working and polished app. Instant gratification beyond max. I’m convinced this is the primary OKR for the team.

• Drag and drop? Flawless. Unlike Replit or Firebase, where drag-and-drop features didn’t work even with multiple prompts, Canvas nails it on the first try.

• Nailed the corkboard UI. Other tools like Replit did okay, but I appreciate the simple yet realistic look & feel.

• Built-in restaurant recs. Add a hotel? It suggests restaurants nearby. Replit and Firebase could never.

• Collaboration, no login required. You don’t need to mess with user auth (which, let’s face it, is the worst part of any tech project).

• “Add Gemini” button = ✨chef’s kiss✨. I didn’t expect anything when I clicked it, and boom — it gave me two useful AI features. That’s the best kind of magic.

• Want more rapid-prototyping experiments and honest AI tool reviews? Subscribe to Vibe Coding Dad.

  Subscribe now

Walkthrough: From Prompt to Pinning

After the prompt, Canvas generated the code and dropped me onto a clean corkboard-style UI.

After creating a new trip, I got an empty board. I could add an additional prompt to help me create some boilerplate activities upon a trip creation. Instead, I added “Tokyo” as a hotel location, and like magic, a few restaurant pins appeared (with no additional prompting).

Automagic restaurant suggestions. Drag & drop was smooth like butter, which no other tools came close.

So far, everything worked like a charm with just a single prompt. Curious about “Add Gemini” button on the bottom right, click it brought up a couple new tools, including a “Suggest Activities” and “Create summary” features.

“Add Gemini” button on the bottom right corner is one of the most magical experience.

The fact that I had no expectation was one of the reasons that this feature blew my mind. Not only did it create two useful features, but they actually work right away.

Clicking “Suggest Activities” button and entering“tokyo”, it instally generated a few top attractions to pin to the board.

One design quirk: the board looks a bit toy-like, which I kind of love. But it’s missing one thing — travel stock images! That visual flair would take it to the next level, and other tools did better in this area.

The board is so much fun. With a bit more tweaking, I’d actually use this to plan my next trip!

The final feature I tested was “Create Summary”, which summed up the trip, and I can see this feature becoming a “printed itinerary” for some travelers.

Product limitations

While Canvas is an amazing tool for the intended, non-technical audience, I do wish there are more advanced feature that I can tweak as tinkerer.

• Only as good as the model. I tried the same prompt with Gemini 2.5 Flash, and… let’s just say it felt like going from iPhone to flip phone. Stick with Pro if you want the wow.

• Multi-user feature is a tease. There’s no real-time collaboration (it claimed it did) or state persistence. Think more “everyone gets their own version” than “true multiplayer.”

• No export to Firebase. Would love a one-click “Host This” option. Copy-pasting could work, but it’s not quite as seamless as it could be.

• No stock images. I only have this expectation because Replit populated stock images. For travel apps, a little photo pizzazz would go a long way.

Final thoughts

Whether you’re a seasoned dev or someone who has never heard of HTML, Gemini Canvas will impress you. Zero setup. No account creation. Just type, click, and marvel. The Canvas team nailed this experience, and I can’t wait to see what people build once they realize just how powerful this is.

As a PM, a former founder/hacker (with an emphasis on hacker, not a real software engineer), and someone whose brain is basically an idea factory, this “vibe coding” concept with AI is proving to be a dream come true. I get to roll up my sleeves, learn the latest AI tricks, AND maybe, just maybe, turn one of these experiments into a real, live app!

So, Why Now? What’s the Big AI Deal?

I’ve had a front-row seat to AI at Box, launching AI APIs and watching things like MCP, AI Agents, and creator productivity totally transform. It feels like we’re in that sweet spot: innovation is still in exponential growth, but things are just stable enough to actually build cool stuff without it changing an hour later. AI is early enough to that new use cases are unfolding daily, but not so bleeding edge that you can’t get your footing on the technology.

My “Vibe Coding” Guiding Principles

Before diving into these AI experiments, I established a few guiding principles:

1. Avoid B2B SaaS Commodity Traps: Having been a B2B SaaS founder and PM for so long, and even bought/sold a SaaS business, I know that many “new” ideas are basically copies of old, but slightly better. The real differentiator often lies in marketing, positioning, and sales. For these personal projects, I’m looking elsewhere.

2. Focus on Passion or Problem-Solving: Time is a luxury these days. If I invest it, I want to be enthusiastic about the project or the problem it addresses.

3. AI-first Approach: The problem should be 10x easier to solve with GenAI compared to traditional programming. The AI should be core to the solution.

4. Potential for a Side Project/Hustle: The ability to turn it into a side income source is a definite plus.

The Hack Lineup

Here are the ideas I’m exploring. This post will focus on the first one:

1. Collaborative AI Travel Planner with Replit) — This is the focus of today’s post.

2. AI Basketball Coach from Video Recordings (with Firebase Studio) — Imagine AI providing tips on your basketball technique. Further imagine that it’s Michael Jordan coaching you! More on this in a future update.

3. Text to Calendar Events (TBD) — To simplify event scheduling. Stay tuned for this one.

4. Ideation Zone: Exploring ideas for transforming blog posts/docs/text into other formats (podcasts, infographics, 3-min videos, etc.). The possibilities are numerous.

Hack #1: Revisiting My Trip Planner Concept with AI & Replit

Let’s go back a bit. Back in 2009, before Pinterest gained widespread popularity and Google Docs became the standard for collaboration, I founded Duffelup.com (coverage by TechCrunch). It was a collaborative and visual trip planner, merging aspects of visual appeal similar to Pinterest with Google Docs’ collaboration features. I’ve always enjoyed planning trips, especially when friends/family also chip in ideas.

Cork board for friends & family to pin ideas

That project involved over two years of nights and weekends learning and coding Ruby on Rails. As the only programmer, I also learned about deploying to AWS (back then, only EC2 existed). This was when I gained experience as a “full-stack developer” somewhat unintentionally. To summarize, it reached over 50k MAU without any marketing, generated a whopping $10/month from affiliates, and I decided the return on investment wasn’t sufficient for the effort involved. I sold it and used the proceeds as a down payment for my VW Golf (not a house, sadly, but still a positive outcome).

Fast forward 15 years. I recently planned a trip to Spain, and the process was familiar: going through notes from friends, copying and pasting ideas into a Google Doc, and manually mapping them to see their locations. I realized that a gap in collaborative travel planning persists. So, I decided to revisit my trip planner concept, this time using Replit to “vibe code” it with AI assistance.

This post isn’t a detailed product review, but here’s a glimpse of the product and some initial learnings:

I asked for a Google Authentication button with the logo. Replit nailed the visuals perfectly on first try. The backend logic? Well, it’s basically vaporware.

I’m impressed that it automatically added a few destinations with images, instead of a blank canvas.

After creating a trip, I can add a few items on this “visual board”. I didn’t further refine the look & feel, which needs more love.

Replit even designed this nifty modal without me even asking.

Prompt #1:

Create a trip planning website that multiple users can collaborate and plan trips together. The website will allow users to create itineraries, add hotels, transportation, top visited sites, and automatically suggest restaurants around the top sites and hotels. The trip planner’s UI will look like a corkboard with drag and drop interface, almost like users are pinning ideas to a board to make trip planning fun and visual.

Prompt #2:

For user authentication, also add Google oauth with a “Sign in with Google” button.

• Instant Gratification: The first prompt spat out basically everything you see in the screenshots. For prototyping? Insanely good.

• PM Dream, Developer’s “Hmm…”: This is fantastic for Product Managers like me to quickly show, “See? This is what I mean!” But, let’s be clear, it’s a galaxy away from a production-ready app. The database isn’t set up, authentication is flaky, drag & drop doesn’t work, etc.

• Deployment Hiccup: Getting it live seemed a bit tricky at first glance. Looks like I’d need to manually set up Firebase, which adds a bit of friction.

Time Spent: Just 1 Hour! This includes signing up to Replit (and I’m the type of person who skips tutorials). For a functional prototype that actually looks like something? Impressive.

That’s the summary on my first AI vibe coding experiment! It’s amazing how quickly you can get an idea off the ground these days.

Stay tuned for updates on my other AI hacks — the AI Basketball Coach is calling my name!

What about you? What AI experiments are you cooking up? Drop your thoughts and ideas in the comments below — I’d love to hear what you’re working on!