DEV Community: cucoleadan

OpenClaw vs Claude Cowork vs Perplexity Computer - Which AI Agent Actually Fits Your Life

cucoleadan — Tue, 17 Mar 2026 13:11:58 +0000

You have a rare opportunity.

Both Anthropic and OpenAI are running 2x usage limits on their paid plans right now. Claude Pro subscribers get double the capacity across Claude AI, Cowork, and Claude Code. ChatGPT Plus subscribers get the same bump across ChatGPT and Codex, which is awesome since you can use your ChatGPT Pro account in OpenClaw.

Same price, twice the output. These promos won't last, and they've given me the perfect excuse to push all of these tools harder than I normally would.

And I needed that, because three weeks ago the AI agent space exploded.

In late February, the AI agent space stacked up fast. OpenClaw shipped a major security and reliability update. Days later, Anthropic launched scheduled tasks for Claude Cowork and Perplexity dropped their Computer product on the same day. Three different companies, three different visions of what an AI agent should be, all landing within the same few weeks.

I've been running OpenClaw on a cloud server for months now. Claude Cowork is my daily driver for local work. I've spent a week with OpenAI's Codex after it launched its Windows app. And I've done a ton of research on Perplexity Computer, watching head-to-head comparisons, reading reviews, and studying how it stacks up against the tools I use daily.

Based on all of that, I wrote this so you can make an informed decision and pick the right tool for your specific use case.

If this kind of breakdown saves you time, follow me X for more like it.

In this article:

The Lineup
Where It Runs
Head to Head
What It Costs
Who Sees Your Data
Pick Yours
Where This Is Going
One More: Codex

The Lineup

Here's the 30-second version of each tool. They look similar on paper but they're built on fundamentally different philosophies.

OpenClaw is a self-hosted, always-on AI agent. Open-source, 319,000+ GitHub stars, recently "acquired" by OpenAI. You install it on a VPS or a Mac Mini, and it runs 24/7. You talk to it over Telegram, WhatsApp, Discord, or whatever messaging platform you prefer. Think of it as a remote employee who never clocks out. You bring your own API keys, your own models, your own rules.

Claude Cowork is a local co-pilot that lives inside Claude Desktop. $20/month on any paid Claude plan. Best UI of the three by a wide margin. The recently added scheduled tasks feature turned it into a lightweight automation tool, letting you set up daily briefings, weekly reports, and recurring workflows. The catch: it only runs while your computer is awake and the app is open.

Perplexity Computer is a cloud-based multi-model orchestrator. It takes your task, breaks it into subtasks, and dispatches them across 19 specialized AI models: Claude Opus for reasoning, Gemini for research, GPT-5.4 for long-context work, Grok for quick tasks. It was locked behind the $200/month Max plan at launch, but it's now available to Pro users ($20/month) through usage credits. Over 400 app integrations including Gmail, Notion, Slack, and Salesforce.

Where It Runs

Every comparison I've read focuses on features, pricing tiers, model benchmarks. None of those tell you as much as one thing: where the agent runs.

This is the fork in the road. Security, reliability, cost structure, and what the tool does for you all flow from this single architectural decision.

On your machine. That's Claude Cowork. Easiest to start. Most polished experience. You install the desktop app, point it at a folder, and you're working. But it dies when your laptop sleeps. Scheduled tasks only fire while the app is open. If you close your lid at 6 PM, your "daily overnight report" never runs. Great for working-hours automation. Terrible for overnight agent dreams.

On your server. That's OpenClaw. True autonomy. It runs while you sleep, eat, and go on vacation. I've had mine running on a Hetzner VPS for months and it processes tasks at 3 AM without me lifting a finger. But you're now a sysadmin. Updates break things. Security is your responsibility. In independent testing it scored a 4 out of 10 for ease of setup. That number feels generous on a bad day.

In someone else's cloud. That's Perplexity Computer. Always on, zero maintenance, no servers to manage. But you're paying a premium for that convenience, and your data flows through Perplexity's infrastructure. With Pro credits now available, the entry barrier dropped significantly. Heavy users will still feel the cost.

I chose to run OpenClaw and Cowork together because I need both modes. If I had to pick only one, the answer depends entirely on whether I need an agent that works while I don't. If you need something running overnight, it's OpenClaw or Perplexity. If your AI work happens during business hours, Cowork is more than enough.

Head to Head

Enough architecture. Here's how they perform across the three categories that matter most.

Research and Reports

Perplexity Computer wins here, and it's not particularly close. The multi-model orchestration means it cross-references sources across different AI systems, and every output includes clickable citations with links in the footer. In one head-to-head test I studied, both tools were asked to research AI invoice automation tools and compile a one-page PDF comparison. Perplexity came back with precise pricing data, clean formatting, and source URLs you could verify in seconds.

Cowork produced a solid report but broke the one-page constraint, got a team plan price wrong, and listed sources by name without linking them. Still usable, about 90% as good, but that missing 10% is the part that matters when you're sending deliverables to a client.

OpenClaw handles research, but it's manual. You prompt, it fetches, you verify. There's no orchestration layer coordinating multiple models behind the scenes. It works. It's slower and requires more hand-holding.

Verdict: If research is your main job, Perplexity Computer earns its price tag. For everyone else, Cowork is good enough.

Working With Your Own Files

Cowork dominates this category. It reads your local filesystem directly. Point it at a folder and it references, reviews, or builds on anything inside it. No uploads, no API overhead, no friction.

I tested Cowork with messy client intake notes: 10 inconsistent text files with different formats, missing fields, and contradictory information. Cowork parsed them all, identified the real business bottleneck for each client, and output a clean structured spreadsheet. In the same test run by a reviewer, Perplexity handled the task but required manual file uploads for each one. It also made a weaker recommendation, suggesting ChatGPT for a client whose real problem was a bad website.

OpenClaw can access server files natively, and if you've built the Nextcloud bridge I wrote about previously, it can reach anything your local AI can reach too. Different path to the same destination.

Verdict: If your work lives in local files, Cowork. If it lives on a server, OpenClaw. If it lives in cloud apps like Gmail, Notion, or Google Sheets, Perplexity Computer's 400+ integrations give it the edge.

Automation and Scheduled Tasks

This is where the "where does it run" question hits hardest.

OpenClaw was built for this. Heartbeats, cron jobs, always-on triggers, multi-platform messaging. It runs whether you're awake or not. I have mine sending me a Telegram summary of my project pipeline every morning at 9 AM. I don't touch anything. It shows up.

Cowork now has scheduled tasks and they work well when they work. Daily, weekly, hourly, on-demand. The UI for managing them is cleaner than anything OpenClaw offers. But the limitation is real: they only execute while your computer is on and the app is open. If your laptop is closed, the task simply doesn't run.

Perplexity Computer can handle multi-hour and even multi-day workflows autonomously in the cloud. For long-running research or complex multi-step tasks, the results are strong. But you're paying cloud prices for that always-on capability.

Verdict: True 24/7 automation means OpenClaw or Perplexity. For business-hours automation, Cowork handles that well.

Know someone choosing between these tools? Share this with them.

What It Costs

Sticker prices lie. Here's what each tool costs when you're using it daily.

Claude Cowork: $20/month. Simplest math of the bunch. One subscription, everything included. No API keys, no hosting bills, no infrastructure to maintain. This is the "I want it to work, no setup" option. And right now, Anthropic is running 2x usage limits on all paid plans. Double the Cowork capacity for the same $20. If you've been waiting to try it, this is the window.

OpenClaw: $0 software + $6-50/month real cost. The software is free and open-source. But you need somewhere to run it. A VPS costs $6-24/month depending on specs. API calls for models like Opus, Gemini Pro, or GPT-5.4 add another $10-200/month depending on how heavily you use it. Light users land under $20 total. Power users blow past $200 easily.

The hidden cost is your time. Setup, maintenance, debugging when an update breaks something. OpenClaw is free in dollars but expensive in hours. I spent an entire evening once debugging a permissions conflict between OpenClaw and Nextcloud on the same server. That evening had a price even if my credit card didn't see it.

Perplexity Computer: $20/month (Pro with credits) or $200/month (Max). The Pro credits path is new and it changes the equation. You get access to the full multi-model orchestrator without the $200 commitment. But heavy workflows eat through credits fast. Max at $200/month is aimed at professionals whose time is worth more than the subscription: consultants, researchers, analysts working on problems where a single good report saves hours of manual work.

The value verdict. Cowork wins on pure value for most people. OpenClaw wins if you already have a VPS and enjoy tinkering. Perplexity Computer's Pro tier makes it worth trying, but Max is only justified if it saves you measurable hours every week. And with both Claude and Codex running 2x promos simultaneously, mid-March 2026 is the cheapest stress-test window you're going to get. Take advantage before it ends.

Who Sees Your Data

This is the part that nobody wants to talk about but everybody should.

OpenClaw has full system access by design. It can read, write, and execute anything on the host machine. In independent testing it scored a 3 out of 10 on security. The low score comes from the architecture itself.

The tool works precisely because it's unconstrained. But if you misconfigure it, everything on that machine is exposed. Your business plans, client files, API keys, all accessible.

Self-hosting means you own the risk and the control.

This is why I run OpenClaw behind my own server with a Nextcloud layer on top. Full control over every file, every model, every connection. But I wouldn't recommend that setup to someone who isn't comfortable managing a VPS and thinking about access control lists.

Claude Cowork is sandboxed to your working folder. It scored a 9 out of 10 on security in the same evaluation. Anthropic handles the model infrastructure, you handle your files. It's the safest option out of the box by a wide margin. If security keeps you up at night, this is your tool.

Perplexity Computer is cloud-based with 400+ integrations. Your data flows through Perplexity's infrastructure and gets routed across multiple model providers. If you trust them, great. If you've built your workflow around data sovereignty and self-hosting, this is going to feel uncomfortable.

Pick Yours

Find yourself in 10 seconds.

Choose Claude Cowork if:

You're non-technical or want zero setup friction
You already pay for Claude Pro, Max, or Team
Your work is mostly local files, writing, and brainstorming
You want scheduled tasks that run during working hours
Budget matters and $20/month all-in sounds right

Choose OpenClaw if:

You want a 24/7 agent that works while you sleep
You're comfortable with a VPS and basic server management
You need mobile access via Telegram or WhatsApp
You want full control over which models you use, where your data lives, and how everything connects
You like open-source and building your own stack

Choose Perplexity Computer if:

Your work is research-heavy and citation quality matters
You need multi-model orchestration across providers
Your workflow already lives in cloud apps like Gmail, Notion, Sheets, or Slack
You want autonomous multi-day task execution without managing infrastructure
You're a Pro user willing to try it with credits, or a professional where $200/month pays for itself in saved time

Use more than one if:

You have different modes of work. Deep focus, always-on automation, and heavy research are three different jobs. These tools aren't mutually exclusive. I run OpenClaw on my VPS for overnight tasks, Cowork locally for writing and brainstorming, and bridge them through Nextcloud so both AIs share the same files. Different tools for different jobs, one shared brain.

Which combo are you running? Drop a comment, I read every one.

Where This Is Going

Three major platforms shipped competing agent features in the same few weeks. All of them converging at once tells you where the industry is heading.

The "build a SaaS wrapper" era is ending. Scheduled email briefings, automated research reports, CRM workflows, client intake processing. These tools do all of that out of the box now. Dozens of startups built businesses around features included in a $20/month subscription.

The surviving play is learning which agent to deploy for which task, how to connect them, and how to make them share context across platforms. The people who figure out how to wire these tools together will have the real edge.

Pick the right combination of agents, matched to how you work, and you'll move faster than anyone stuck choosing sides.

One More: Codex

I've only been using Codex for a week, so it's not in the main comparison. But it deserves a mention because it's solving a different problem entirely.

Codex is OpenAI's cloud-based coding agent, powered by codex-1, a version of o3 optimized specifically for software engineering. It comes in three flavors. Codex Web is the autonomous cloud version: you give it a task, it spins up a sandboxed environment, works for 1 to 30 minutes, and comes back with a pull request. You can fire off multiple tasks in parallel.

Codex Desktop launched on Windows recently, which is how I've been running it, as a native app on my machine alongside Claude Desktop. Codex CLI is the open-source command-line version, similar in spirit to Claude Code.

Codex stays in one lane: software engineering. Writing code, fixing bugs, answering codebase questions, and proposing pull requests. Where the main three tools try to be general-purpose assistants, orchestrators, or always-on agents, Codex focuses on code and nothing else.

It's included with ChatGPT Plus at $20/month with usage limits. Pro at $200/month gets 6x the capacity.

And right now, OpenAI is running 2x usage limits on Plus, so you get double the Codex tasks for the same $20. Pair that with Anthropic's own 2x promo on Claude, and mid-March 2026 is the best window to trial both ecosystems side by side.

My early impressions after a week on the Windows app: the cloud execution model is the standout feature. Fire off a task and go do something else. No terminal babysitting. I kicked off three bug fixes simultaneously and reviewed them all when they came back.

The sandboxed environment means it can't break your local setup, which is a relief compared to OpenClaw's "full access to everything" philosophy. And it cites terminal logs and test outputs as evidence, so you can trace exactly what it did and why.

But it's early days. I haven't stress-tested it on complex multi-file refactors yet, and I don't know how it handles edge cases in large codebases. For developers, it fills the same focused coding role in your stack. For non-developers, it won't add much.

I'll write a full breakdown once I've spent more time with it. For now: if you're already paying for ChatGPT Plus, you have access. Go try it while the 2x limits last.

If this helped you pick the right tool, follow for more real-world breakdowns like this one.

Forgetting to Forget - How Infinite Memory Reinvents OpenClaw

cucoleadan — Tue, 10 Mar 2026 15:08:35 +0000

I've been running OpenClaw for a few weeks now and got familiar with its pros and cons. One thing I love about it is that it saves every conversation and, if configured correctly, it can search through all past sessions.

On paper, the memory system works. In practice, it has gaps.

I'd reference a decision from two weeks ago and the agent would pick it up fine. Then I'd ask about something equally important from the same week and get a random response.

The conversations were there, stored and searchable, but the retrieval was inconsistent. Important context slipped through the cracks, not every time, but often enough that I stopped trusting it to remember the things that mattered.

After long workflow runs where subagents coordinated multi-step tasks, the problem got worse. The agent would lose track of what happened mid-chain, missing details that should have been obvious given the work it just completed.

I found myself re-explaining decisions, re-stating preferences, and mentally tracking which parts of our shared history the agent could actually access versus which parts had quietly fallen out of reach.

OpenClaw v2026.3.7 fixes this.

The update introduces a pluggable context engine architecture and the lossless-claw plugin, making it possible for the first time to retain absolutely everything across days, weeks, months, or years. And no, this is not a premium feature locked behind a paywall, after all OpenClaw is, well, Open Sourced.

I really believe this is the beginning of genuinely intelligent agents available to anyone willing to put in the work and self-host them.

Here's my take on how to set this up for your OpenClaw and what it might mean in the long term.

No More Starting Over

The system no longer forgets who I am the moment I close the window. Every command, every conversation, every preference builds uninterrupted continuity. I pick up exactly where I left off the night before.

Here's what a typical workflow looks like now. I tell my assistant:

Follow up on yesterday's discussion and start drafting an email campaign. Keep my usual tone and the branding guidelines we cemented last week.

The assistant already knows my "usual tone." It's been watching me work for a few days (since the update came in). The branding guidelines I established are preserved, searchable, and actively informing every new output.

The old setup forced me into a cycle of pasting documents or pulling info from my Notion DB. I also found myself searching through the /memory folder for a past convo and pasting that inside my Telegram chat. That was really a massive time waster.

Now with this upgrade I won't have to do all that. Yeah, it works for massive conversations, but I don't want to save every little, unimportant thing, but more on that later.

The End of the Context Tax

Every new AI session used to demand a toll. Re-establish who I am. Re-explain the project. Re-state my conventions. This "context tax" consumed time and mental energy better spent on actual work.

Sure, you can just update your MEMORY.md and AGENTS.md, even the IDENTITY.md, but you shouldn't pollute these super important files with info you need to fetch on demand.

Think of a developer re-explaining their tech stack loses five minutes per session. Over a quarter, those minutes add up to hours burned on orientation instead of output.

Or writers restating brand voice, marketers re-uploading style guides, project managers re-establishing timelines. Everyone pays the context tax, nobody benefits.

Infinite memory removes this friction entirely. The entire history becomes the implicit foundation for every new request, which let's you jump directly into substantive work.

The productivity gains are measurable. Intelligence requires context and memory to function meaningfully. When the assistant retains everything, outputs become exponentially more accurate and relevant.

Why Previous Memory Systems Fell Short

Older systems relied on basic vector searches to retrieve relevant conversation fragments. When I asked a question, the system computed an embedding, searched a vector database for similar embeddings, and retrieved matching fragments. When it wanted to.

The problem: vector similarity is a poor proxy for actual relevance.

A search for "authentication" might return discussions about password hashing from six months ago, even though the current question is about OAuth implementation in a completely different project. The context window fills up with marginally relevant fragments, causing the model to hallucinate or lose track of the conversation thread.

And that's how I involuntary become sort of a memory manager. I pruned chats, started fresh sessions, and developed elaborate "starter prompts" pasted at the beginning of every session to reconstruct context the system should have retained on its own.

None of these workarounds addressed the core problem. Vector retrieval alone doesn't capture the nuanced thread of a long-term working relationship.

How Lossless Claw Fixes This

Lossless Claw takes a fundamentally different approach. It replaces the AI's "forgetting" mechanism with a permanent memory system. Every conversation is stored in a fast local SQLite database, while a background AI (Gemini 3.1 Flash-Lite in my case) silently summarizes older messages into a compressed, intelligent graph.

When you need context, the system retrieves exactly what's relevant from this history, combining it with your recent messages, so the AI never forgets what matters, even months from now.

The Boring, Technical Architecture

Jump right ahead if you don't care about the ins and outs of how this works.

The system keeps the most recent 20 messages completely untouched in the "fresh tail." Whatever I'm actively discussing remains in perfect, verbatim context. This means fast responses because the model has exact quotes from the active workflow rather than summaries or approximations.

Once a message ages out of the fresh tail, a background process kicks in. Gemini 3.1 Flash-Lite silently summarizes and compresses those older messages into a dense graph structure. The SQLite database stores these nodes efficiently, preventing system bloat while maintaining instant accessibility. This compression runs automatically on a schedule, keeping history growth manageable without any manual intervention.

When I ask a complex question requiring past knowledge, the system pulls from the compressed graph up to a 150k token retrieval limit. This boundary guarantees the main model has enough room to read relevant history and generate a high-quality response without slowing down.

And the retrieval is really smart. Rather than dumping raw tokens into the context window, the system identifies the portions of history relevant to the current query and surfaces those specific sections.

Think of it as a research librarian versus a keyword search.

A keyword search returns every document mentioning a term. A librarian understands the question, knows the project, and brings the three documents that matter. The compressed graph gives the assistant that librarian's judgment.

Setting Up Lossless Claw

No code. No terminal. No config files. The entire setup is conversational.

Tell your OpenClaw this:

Install this https://github.com/Martian-Engineering/lossless-claw and let's configure it once it is done.

One prompt. The plugin manages the SQLite lifecycle internally, covering database initialization, optimization, and maintenance without running a single command.

Integrating memory into existing agents is equally straightforward. Tell your agent:

Create a persistent memory profile for each of my active agents using the lossless-claw plugin.

Whether there are separate agents for coding, writing, or project management, each one maintains its own coherent memory growing over time. The system stays invisible, surfacing forgotten context exactly when it's needed.

For anyone who's already been running OpenClaw and has existing conversation history worth preserving, tell the gateway:

Import my existing conversation history into the lossless-claw memory graph and index it for retrieval.

The system ingests past sessions, compresses them through the same summarization pipeline, and makes them part of the permanent memory from day one. No history left behind.

Professional Tuning and My Settings

These are settings I use when I run OpenClaw with Gemini 3.1 Pro Preview Custom Tools.

Distillation threshold: 0.25

This low threshold triggers the summary process early, keeping the active window clean and leaving plenty of room for complex reasoning. Early distillation means the context window stays usable even during long, demanding sessions. Tell the assistant:

Set the lossless-claw distillation threshold to 0.25.

Fresh tail: 20 messages

Preserving the last 20 messages as raw text ensures the agent understands the current flow and the most recent shifts in the conversation. Summarizing too early kills nuance. The back-and-forth of a debugging session or the evolution of an idea within a single sitting needs full fidelity to stay coherent.

Retrieval limit: 150k tokens

This is the sweet spot between depth and speed. When I need to recall a decision from six months ago, the system pulls it in instantly while still leaving room for the current task.

Set my retrieval limit to 150k tokens and the fresh tail to 20 messages.

Why Flash-Lite Powers the Background

I use Gemini 3.1 Flash-Lite to handle the summarization layer. This is a secretary task that doesn't require a high-cost reasoning model to compress facts, and Flash-Lite is built for exactly this kind of work. And it's dirt cheap.

Team Memory and Shared Knowledge

I run OpenClaw solo most of the time, but the team angle is worth talking about.

Right now, each person's agent works in isolation. No shared memory of decisions, conventions, or project history. A new team member has to absorb months of tribal knowledge by asking around. Every agent profile starts from zero.

Shared memory profiles fix this. The reasoning behind picking one database over another lives in the agent, not in someone's head or a forgotten Slack thread. Onboarding becomes less about catching people up and more about pointing them at a system already loaded with context.

For agencies managing multiple clients, each client agent keeps its own partitioned memory. The tone and history for one account never bleeds into another.

And this also applied to a team of AI agents, not necessarily to your coworkers.

Security and Privacy

The first thing people ask about persistent memory is where the data lives.

On my machine. The SQLite database, the summarized graph, all of it stays local unless I configure it otherwise. Summarization runs locally too, through models I control. Nothing goes to a third-party server to become training data, if I don't want to.

I own the history. I control the models touching it. And if I need to wipe something, i just tell my OpenClaw:

Purge all memory nodes related to [project name] from my agent profile.

The memory is permanent by default, but deletion is one prompt away.

What Infinite Memory Changes

The most useful part of this update is everything I stopped doing.

I stopped managing memory by hand. I stopped pasting old conversations into new sessions. I stopped wondering whether the agent remembered the decision we made last Tuesday when it answered with something that sounds a bit strange.

The agent feels less like a tool I operate and more like a collaborator who has been around long enough to know how I think. I did not expect this shift to happen so fast.

OpenClaw almost crossed 300,000 stars on GitHub. The project started as an experimental framework and is becoming something closer to an agent operating system, and infinite memory will play a big role in this.

How to Install and Configure PicoClaw on the Cheapest VPS

cucoleadan — Tue, 17 Feb 2026 14:49:01 +0000

OpenClaw's creator, Peter Steinberger, just joined OpenAI. The project will live on as an open-source foundation, but when the person who built the thing moves to a company with its own agent ambitions, it's worth looking at what else is out there.

PicoClaw launched the same week, claims it can run a full AI agent on a $10 Raspberry Pi with less than 10MB of RAM, and it's already sitting at 12K GitHub stars. That's a bold pitch for a framework that's barely a week old.

I wanted to see if it holds up.

So I grabbed the cheapest ARM server Hetzner sells (€3.79/month), installed PicoClaw from scratch, connected it to OpenRouter for LLM access, and wired up a Telegram bot so I can talk to it from my phone.

This is the complete walkthrough of that process, every step from a blank server to a working AI assistant.

Follow me on X for more like this

Prerequisites

Before starting, make sure you have:

A Hetzner server or any other VPS;
An OpenRouter account and API key;
A Telegram account (for bot setup).

Fair warning: I wrote this so that anyone can follow along, even if you've never touched a terminal before. Every command is copy-paste ready. But "easy to follow" doesn't mean "zero context needed." You're spinning up an AI agent on a server you control. You should at least know what a VPS is, what an API key does, and not panic when you see a command line. If that's you, let's go.

Installing Dependencies

First, SSH into your server and install the required build tools. PicoClaw is written in Go, so you'll need make to handle the build process.

apt update
apt install make -y

This installs the make utility, which will orchestrate the compilation process defined in PicoClaw's Makefile.

Cloning and Building PicoClaw

Clone the PicoClaw repository from GitHub:

apt update
apt install git -y
git clone https://github.com/sipeed/picoclaw.git

Navigate into the project directory and install Go dependencies:

cd picoclaw
apt install golang-go -y
make deps

This command downloads and installs all Go modules required by the project (similar to npm install for Node.js or pip install -r requirements.txt for Python).

Once dependencies are installed, compile the source code:

make build

This command compiles all .go files into a single picoclaw binary executable.

Finally, install the binary to your system path:

make install

The make install command copies the compiled binary to /usr/local/bin/ (or similar), making it accessible from anywhere on your system. That’s it, now let’s connect it to a model.

Connecting to OpenRouter

PicoClaw needs an LLM provider to function. This guide uses OpenRouter as an AI gateway, which provides access to multiple models through a single API.

Getting Your OpenRouter API Key

Sign up at https://openrouter.ai/
Navigate to https://openrouter.ai/settings/keys
Create a new API key (name it something memorable like "PicoClaw")
Copy the key immediately as you won't be able to see it again:

Configuring the API Connection

Create the configuration file with your API credentials. Replace YOUR_OPENROUTER_API_KEY with the key you just copied:

cat > /root/.picoclaw/config.json << 'EOF'
{
  "agents": {
    "defaults": {
      "workspace": "~/.picoclaw/workspace",
      "model": "google/gemini-3-pro-preview",
      "max_tokens": 8192,
      "temperature": 0.7,
      "max_tool_iterations": 20
    }
  },
  "providers": {
    "openrouter": {
      "api_key": "YOUR_OPENROUTER_API_KEY",
      "api_base": "https://openrouter.ai/api/v1"
    }
  }
}
EOF

Security Warning: This configuration stores your API key in plain text. Ensure your server is properly secured with SSH key authentication, firewall rules, and restricted user access. Anyone with file system access can read this key.

Testing the Connection

Verify that PicoClaw can communicate with OpenRouter:

picoclaw agent -m "Hello, are you working?"

This did not work for me on the first try because the binary is installed to /root/.local/bin/picoclaw, but that directory wasn't in my PATH. So I ran:

echo 'export PATH=$PATH:/root/.local/bin' >> ~/.bashrc
source ~/.bashrc

This fixed the issue and I got a response!

If configured correctly, you should receive a response from the AI model as well.

Setting Up Telegram Integration

Running PicoClaw from the command line works, but integrating it with Telegram provides a much more convenient interface for daily use.

Creating a Telegram Bot

Open Telegram and search for @BotFather
Send the command /newbot
Follow the prompts to choose a name and username for your bot
Copy the bot token (format: 123456789:ABCdefGHIjklMNOpqrsTUVwxyz)

Getting Your Telegram User ID

To restrict bot access to only your account:

Search for @userinfobot on Telegram
Send it any message
Copy the numeric Id it returns (e.g., 123456789)

Configuring Telegram Access

Install jq for JSON manipulation:

apt install jq -y

Update the PicoClaw configuration to enable Telegram integration. Replace YOUR_TELEGRAM_BOT_TOKEN and YOUR_TELEGRAM_USER_ID with your actual values:

jq '
  .channels.telegram = {
    "enabled": true,
    "token": "8534006675:AAEQasMkndYFB_039eT2q8nwEFe1IY7ZJWY",
    "allowFrom": ["1606858324"]
  }
' /root/.picoclaw/config.json > /tmp/config.json \
  && mv /tmp/config.json /root/.picoclaw/config.json

The allowFrom array restricts who can use your bot. Only Telegram user IDs listed here will be able to interact with your AI agent.

Starting the Gateway

Launch the PicoClaw gateway to activate the Telegram bot:

picoclaw gateway

Once the gateway is running, open Telegram, navigate to your bot, and click Start. You should now be able to chat with your PicoClaw agent directly through Telegram.

Running PicoClaw as a Background Service

By default, PicoClaw runs in the foreground and stops when you close the terminal or press Ctrl+C. To keep it running permanently, set it up as a systemd service.

Creating the Service File

Create a systemd service definition:

cat > /etc/systemd/system/picoclaw.service << 'EOF'
[Unit]
Description=PicoClaw Gateway
After=network.target

[Service]
ExecStart=/root/.local/bin/picoclaw gateway
Restart=always
RestartSec=5
Environment=HOME=/root

[Install]
WantedBy=multi-user.target
EOF

Enabling and Starting the Service

Reload systemd to recognize the new service:

systemctl daemon-reload

Enable the service to start automatically on boot:

systemctl enable picoclaw

Start the service immediately:

systemctl start picoclaw

Monitoring the Service

Check the service status:

systemctl status picoclaw

View real-time logs:

journalctl -u picoclaw -f

PicoClaw now runs in the background, automatically starts on server reboot, and restarts itself if it crashes.

Your PicoClaw is Up-and-Running

You now have a fully functional PicoClaw installation running on your VPS, accessible through Telegram from anywhere. This setup provides a personal AI assistant with persistent conversation history and the flexibility to customize the underlying model through OpenRouter.

About the Experiment: This installation serves as a head-to-head comparison with my OpenClaw instance. While PicoClaw appears more optimized and lightweight on paper, OpenClaw has been my reliable daily driver. I'll be monitoring both over the next few days to evaluate:

Resource consumption (CPU, RAM)
Response times and reliability
Model routing efficiency through OpenRouter
Overall user experience

Follow me on X to keep up with what I do and this experiment's results.

The main wildcard is whether OpenAI's involvement will transform OpenClaw into a proprietary "Claw" product. If that happens, PicoClaw's open-source nature makes it the more sustainable long-term choice for self-hosted AI agents.

If you’re building with AI right now you should probably check this out. It’s a collection of 26 mental models to help you figure out what to build before you waste weeks coding.

cucoleadan — Wed, 07 Jan 2026 09:49:24 +0000

26 Mental Models to Build Better Products in 2026

cucoleadan ・ Jan 7

#promptengineering #discuss #productivity #startup

26 Mental Models to Build Better Products in 2026

cucoleadan — Wed, 07 Jan 2026 09:46:41 +0000

This post was originally published as the 26 Mental Models to Build Better Products in 2026 in my VSL Substack publication.

Two weeks of coding magic, one flawless launch and one very sad-looking usage chart. That’s what usually hits you when you build before you validate.

It feels great to create until you realize you built the wrong thing beautifully.

AI makes it dangerously easy to build everything, but it won't tap you on the shoulder when you're building the wrong thing.

The mental models I’m about to share are the thinking patterns that prevent this. They're quiet questions you should ask yourself before touching code.

So get ready because this is going to be a long one. I’ve put together 26 frameworks to help you decide what to build before you build it.

You can bookmark this and come back to it when you're stuck between options or unsure if an idea is worth your time.

WHY This Matters

When you skip product thinking you end up building features nobody asked for. You solve problems that don't exist and waste weeks on code that, in the end, gets deleted.

The pattern is predictable. You prompt AI to build a feature and deploy it perfectly, only to watch users ignore it while you wonder why flawless code didn't lead to adoption.

Unfortunately, the problem was your judgment and not the execution.

Maybe you didn't validate if the feature mattered and ended up building something users don't need. Or you didn't check if users would understand it and ended up creating confusion instead of clarity.

And if there was something I would’ve paid to be told last year was that product mistakes compound quickly.

That unused feature sits in your repo needing maintenance and ends up complicating your codebase for months. It confuses new users and ends up wasting debugging time that should have gone toward features people actually use.

The real price you pay is opportunity cost. Features that would have mattered don't exist because you spent your energy building the ones that didn't.

And that’s why you must start with product thinking before writing a single prompt.

What’s A Mental Model About

Mental models are reusable thinking patterns that help you make better decisions faster.

Experienced product builders use these instinctively. Before writing any code, they ask specific questions:

Who's this for?
What problem does this solve?
How will people discover this?
What's the simplest version that works?
What breaks if we get this wrong?

These frameworks are not random questions. The same pattern you use to evaluate a new feature also applies to pricing changes, onboarding flows, and API design. Learn the model once, use it everywhere.

Three core principles

Decision frameworks beat implementation details. Mental models help you evaluate options before you start building. They won't tell you how to code something, but they will tell you if you should code it at all.

Pattern recognition works across contexts. The "build vs. buy" model works for authentication just as well as it does for analytics. The "jobs to be done" model applies to landing pages just as well as feature prioritization. You are building a toolkit that works across every decision you face.

Prevention always beats fixing. You catch product mistakes in your head when changes cost nothing instead of catching them in production when they cost everything.

Think of these models as a senior product manager reviewing your ideas before you build.

They ask the hard questions early to force you to check if you validated demand, or if users truly understand the value.

But the real difference between a person and these models is speed.

A senior PM takes days to give feedback while these models take just five minutes.

Needless to say that if you can afford a senior PM you should definitely run things by them.

The 26 Mental Models Framework

Product Validation Models

These cover what to build and when

1. The Mom Test

Decides: Whether your product idea solves a real problem

When to use: Before building anything, especially when validating with friends/family

Your mom will tell you your app idea is great because she loves you. Friends will say "I'd totally use that!" because they don't want to hurt your feelings.

The model works like this: Ask people about their current behavior instead of asking then if they would use your solution.

"Would you pay for a tool that organizes your bookmarks?" is worthless.

"Tell me about the last time you couldn't find a bookmark you saved" reveals whether this problem actually exists in their life.

Key questions: What did you do the last time you faced this problem? How much time/money did it cost you? What solutions have you tried? How much would it be worth to solve this?

What makes it different: Forces conversations about past behavior and real pain, not hypothetical interest and polite encouragement.

2. The Ramen Profitable Filter

Decides: If this feature/product can generate enough revenue to sustain you

When to use: When choosing between multiple product ideas or features

You need to build something that makes enough money to keep you building rather than a unicorn.

The filter asks: Can I get to 10-50 paying customers with this specific solution? It's a mistake to start with "will this scale to millions?" Just "can I find my first 50 people who will pay?"

Example: You're choosing between building AI-powered resume optimization (massive market, huge competition) or a niche tool for freelance podcast editors to manage client revisions.

The resume tool might scale bigger. The podcast tool can get to 50 customers in communities you already know, like Substack, Reddit, Facebook groups or Discord servers where editors hang out.

Key questions: Who are the first 10 customers by name or community? What's the specific painful problem they have right now? What's a reasonable price they'd pay monthly? Does 10-50 customers at that price cover your living costs?

3. The Hair-On-Fire Problem

Decides: Whether the problem is urgent enough that people will switch to your solution

When to use: Validating problem severity before building

Problems come in two categories: hair-on-fire urgent and "yeah, that's annoying." Only the first category makes people switch tools.

If someone's hair is on fire, they don't politely research solutions. They grab whatever's closest. That's the urgency level you need.

Example: Losing customer data because your backup system failed? That’s the Hair-on-fire scenario which forces you to buy a solution today. Manually copying data between two tools that takes 10 minutes weekly? Annoying, but you'll keep doing it for months before switching.

Key questions: Are users actively searching for solutions right now? Have they tried multiple existing solutions? Would they pay to solve this today or "eventually"? What's their current painful workaround?

What makes it different: Separates "nice to have" features that never gain traction from "must have" solutions people adopt immediately.

4. The Unfair Advantage Test

Decides: Why you can build this better than anyone else

When to use: Before committing to a product direction in a competitive space

Every idea sounds good until someone with more resources copies it in two weeks.

Your unfair advantage is something that can't be easily replicated: unique data access, specialized expertise, an existing audience, proprietary technology, or deep domain knowledge.

Example: Building a generic project management tool? No unfair advantage because Notion, ClickUp, and fifty others already exist. Building a project management tool specifically for film production crews using terminology and workflows you learned from 10 years in the industry? That's an unfair advantage competitors can't copy without living your experience.

Key questions: What do I have that competitors would need years to build? Can this be copied with money alone? Does this advantage matter to customers?

5. The MVP Scope Guillotine

Decides: What's actually essential for the first version

When to use: When scoping your first version or any major feature

The guillotine is brutal: If users can accomplish their core goal without this feature, it doesn't make V1.

Here's how to use it: State the core user goal in one sentence. Then evaluate each planned feature: "Can users accomplish [core goal] without this?" If yes, cut it.

Example: Core goal: "Help freelancers send professional invoices and get paid."

Features you're considering:

Create invoice with line items → Essential (can't invoice without this)
Send invoice via email → Essential (can't get paid if client doesn't receive it)
Accept credit card payments → Essential (need a way to get paid)
Recurring invoices → Cut it (they can manually create monthly invoices)
Expense tracking → Cut it (doesn't help them invoice clients)
Client portal → Cut it (email works fine for V1)
Multi-currency → Cut it (start with one market)

What makes it different: Most builders include features that feel important but aren't necessary. This model forces you to be honest about what's truly essential.

User Experience Models

Decide what users are going to use and what they won’t

6. The Jobs-To-Be-Done Lens

Decides: What outcome users are hiring your product to deliver

When to use: Designing features, writing copy, planning onboarding

Users actually hire products to get a job done. Nobody wants a drill. They want a hole in the wall so they can hang a picture so their living room feels complete. The same applies to a piece of software

This lens shifts your focus from features to outcomes.

Example: You're building a time-tracking app.

Feature-focused thinking: "Users need start/stop timers and project categories."

Jobs-focused thinking: "Users need to bill clients accurately without manually reconstructing what they worked on."

That insight changes everything. In this case the job is generating accurate invoices rather than just tracking time. So maybe the solution is not manual timers but automatic time detection.

Key questions: What's the user trying to accomplish? What's their life like before and after using this feature? What alternatives are they using now? What job is that alternative really doing?

7. The Empty State Problem

Decides: How to design the experience when users have no data yet

When to use: Every time you build a dashboard, list view, or data display

Most builders design for the full state. During development you use dummy data so your dashboard is populated with numbers, graphs, and activity. But every user starts with nothing. Empty states either guide users to success or lose them immediately.

Example of empty state failure: User signs up for your analytics tool. They land on a dashboard showing... blank graphs and "No data available." They don't know what to do next. They close the tab.

Example of empty state success: Same dashboard, but empty state shows: "Connect your first data source to see insights" with a big button labeled "Connect Google Analytics." Below: "This takes 2 minutes and you'll see your first dashboard immediately." ***Clear next action.*

Key questions: What does a first-time user see? Is the next action obvious? Does the empty state feel broken or intentionally helpful? Can they reach a "success" state in their first session?

8. The Error Message Principle

Decides: How to communicate what went wrong and what to do next

When to use: Writing any error, warning, or validation message

"Invalid input" is useless. "Email addresses can't contain spaces. Please remove any spaces and try again" tells users exactly how to fix it.

The principle has three parts: (1) What went wrong, (2) Why it's wrong, (3) How to fix it.

Bad error message: "Authentication failed"

Good error message: "Wrong password. Check your caps lock and try again. [Reset password]"

Bad error message: "File upload error"

Good error message: "This file is 12MB but our limit is 10MB. Try compressing it or splitting into smaller files."

Key questions: Does this message explain what specifically went wrong? Does it tell users how to fix it? Would someone non-technical understand this?

9. The Progressive Disclosure Pattern

Decides: How much information to show at once

When to use: Designing complex interfaces, multi-step processes, settings pages

Showing everything at once overwhelms users. Progressive disclosure reveals information in layers starting with basics and only showing advanced options when needed.

Example: Settings page with 40 options all visible at once? Overwhelming. Settings page organized into "General" (5 basics visible) with "Advanced Settings" collapsed below? Manageable.

The pattern works in onboarding too: Don't explain every feature on day one. Show the core workflow first. Introduce advanced features when users are ready.

Key questions: What does every user need to see immediately? What can wait until they ask for it? Can beginners accomplish their goal without seeing advanced options?

10. The Feedback Loop Check

Decides: Whether users understand that their action worked

When to use: Any user action including buttons, forms, saves, deletions

Users click "Save." The button does nothing visible. Did it work? They click again. And again. Now they've created three duplicate entries because there was no feedback.

Every user action needs a closed feedback loop: Loading state (processing), success state (it worked), or error state (it failed).

Examples:

Button click → Button shows spinner → Success message appears → Button returns to normal
Form submission → "Saving..." indicator → "Saved successfully" with checkmark → Form clears or navigates
File upload → Progress bar → "Upload complete" → File appears in list

Key questions: After clicking/submitting, does the user know immediately that something is happening? Do they know when it's complete? If it fails, do they know what went wrong?

Technical Decision Models

Decide if that feature is worth your time and effort

11. The Build vs. Buy Scorecard

Decides: Whether to code it yourself or use a third-party service

When to use: Evaluating authentication, payments, email, analytics, search

Use a scoring system with three questions, each rated 0-10:

Is this core to my product's unique value? (0 = commodity, 10 = your secret sauce)
Is there a battle-tested solution I can buy? (0 = I'd need to build it, 10 = Stripe/Auth0 level quality exists)
Will building this take more than one week? (0 = few hours, 10 = months of work)

If questions 2 and 3 score high (15+ combined), buy it. If question 1 scores high (8+), consider building.

Example: Authentication for your SaaS

Core to your value? 2/10 (everyone needs auth, it's not your differentiator)
Battle-tested solution exists? 10/10 (Clerk, Supabase Auth, Auth0, dozens of options)
Takes more than a week? 9/10 (OAuth, password reset, session management, security is complex)

Score: Buy it. You'd spend weeks building something that Clerk gives you in 30 minutes.

Counterexample: Your AI-powered keyword research algorithm

Core to your value? 10/10 (this IS your product)
Battle-tested solution exists? 3/10 (generic SEO tools exist but not your specific approach)
Takes more than a week? 8/10 (yes, it's complex)

Score: Build it. This is your unfair advantage.

12. The Complexity Budget

Decides: Whether this solution is too complicated for the problem

When to use: Choosing between simple and sophisticated solutions

Every abstraction, pattern, library, and framework you add is debt. You maintain it forever, debug it, explain it to AI, and work around its limitations. You have a limited complexity budget so you must spend it wisely.

Example: You need to store user preferences (theme, language, timezone).

Complex solution: Set up Redis for caching, create a separate microservice for preferences, implement pub/sub for real-time updates across sessions, add GraphQL subscriptions.

Simple solution: Add three columns to your users table. Read them on login. Update them on save.

The complex solution might be "better" architecturally. But is it worth the complexity for a feature that reads three values on login? That's the budget question.

Key questions: What's the simplest solution that works? What complexity am I adding and why? Will I still understand this code in six months? Am I solving today's problem or a hypothetical future problem?

13. The Data Architecture Question

Decides: How to structure your database and relationships

When to use: Planning database schema for a new feature

Design your database for the queries you'll run most often, not for theoretical elegance.

Example: Building a blog platform. Each post has an author, tags, and comments.

Read patterns you'll have:

Show all posts (with author name and tag names) → Happens constantly
Show one post with all comments → Happens constantly
Show all posts by one author → Occasional
Show all posts with a specific tag → Occasional

This tells you: Denormalize author name and tag names onto posts table for fast listing. It's okay to repeat data if it makes your common queries fast. The "perfectly normalized" approach requires joins on every page load.

Key questions: What data will I fetch on every page load? What queries will users run most often? Is it okay to duplicate some data for speed? Can I add an index to make this fast?

14. The Good Enough Threshold

Decides: When to ship vs. keep refining

When to use: Before every deployment when you're tempted to add "just one more thing"

Perfectionism kills momentum. Ship when it solves the core problem, even if it's not polished because you can always iterate.

Example: You built a contact form. Current state:

✅ Users can enter name, email, message
✅ Validation works
✅ Submissions save to database
✅ You get notified
❌ No auto-reply confirmation email
❌ No fancy animations
❌ No file attachments
❌ No CAPTCHA

Key questions: Does the "happy path" work reliably from start to finish? Is this missing feature a functional blocker, or just embarrassing to my ego? Will the user fail to achieve their primary goal without this? Can I manually handle the edge cases for the first 10 users?

15. The Third-Party Risk Assessment

Decides: Whether to depend on an external service

When to use: Integrating any API, library, or platform

Every external dependency creates a blast radius where their failure, pricing changes, or disappearance becomes your emergency.

Risk tiers:

Acceptable risk: Stripe for payments. If Stripe fails, payments fail, but that's true for everyone. Stripe is battle-tested and reliable. The alternative is building your own payment processor, which is insane.

Moderate risk: Segment for analytics. If it fails, you lose tracking data, but your app still works. The alternative is sending events directly to multiple analytics tools, which is annoying but manageable.

Dangerous risk: Your entire app depends on one founder's side project API that could shut down tomorrow. If it fails, your app fails. No fallback exists. This is unacceptable risk.

Key questions: What breaks if this service fails? How likely is failure? How hard is it to switch to an alternative? Is this service core infrastructure or a nice-to-have feature?

AI-Assisted Building Models

Decide when the AI is right and when it is wrong

16. The AI Review Checklist

Decides: Whether AI-generated code is production-ready

When to use: After AI generates any code before you commit it

AI models default to the "happy path," writing code for a perfect world where inputs are valid, APIs never fail, and bad actors don't exist.

AI has five predictable blind spots. Check these every time:

✅ Validation: Does it validate user input on both frontend and backend?

✅ Error handling: What happens when API calls fail, files are missing, or data is malformed?

✅ Edge cases: What if the user uploads a 500MB file? Enters emoji? Submits the form twice?

✅ Security: Does it sanitize inputs? Check permissions? Prevent injection attacks?

✅ Performance: Will this work with 1,000 records? What about 100,000?

Example: AI generates a file upload function.

What AI probably included: Basic upload logic, saving to storage, returning success.

What AI probably missed:

File size limits (user uploads 2GB video, server crashes)
File type validation (user uploads .exe file, security risk)
Error handling if storage is full
What happens if upload is interrupted
Duplicate filename handling

Run through the checklist. Add what's missing.

17. The Feature Architecture Sketch

Decides: How to structure a feature before prompting AI

When to use: Before building any non-trivial feature

Five-minute sketch saves hours of AI going in circles. Map the data flow: User action → Frontend → Backend → Database → Response

Example: Building a "save for later" feature for articles.

Quick architecture sketch:

1. User clicks "Save" button on article 
2. Frontend: Disable button, show spinner
3. Frontend: Send POST to /api/saves with article_id
4. Backend: Check if user is authenticated
5. Backend: Check if article exists
6. Backend: Check if already saved (prevent duplicates)
7. Backend: Insert into saves table with user_id + article_id + timestamp
8. Backend: Return success with saved article data
9. Frontend: Update UI to show "Saved" state, enable button
10. Handle errors: Not authenticated, article not found, database error

Now when you prompt AI, you give it this sketch. AI knows exactly what to build. Without the sketch, AI makes assumptions and you spend an hour iterating.

Key questions: What triggers this feature? What data moves where? What can go wrong at each step? What does success look like? What does failure look like?

18. The Context Window Strategy

Decides: What information to include in your AI prompts

When to use: Starting any new feature or debugging complex issues

Strategic context makes AI 10x more useful. Random context makes it confused.

What to include:

Database schema (relevant tables only)
Existing code patterns from your project
Error messages (full stack trace)
Specific requirements and edge cases

What to skip:

Implementation history ("I tried X then Y")
Vague goals ("make it better")
Unrelated code
Your entire codebase

Example of a good prompt:

I need to add email validation to my signup form.

Current schema:
users table: id, email, password_hash, created_at

Current pattern (from login.ts):
We use Zod for validation
We return errors as {field: string, message: string}
We validate on both frontend and backend

Requirements:
Check for valid email format
Check if email already exists (return friendly error)
Case-insensitive email check
Trim whitespace before validating

Generate the validation function for backend.

This prompt includes schema, existing patterns, and specific requirements so AI can generate exactly what you need.

19. The Iteration Pattern

Decides: How to improve AI output without starting over

When to use: When AI code almost works but has issues

Iterate surgically. Point to the specific problem and requested change.

The pattern: (1) Identify the specific line or section, (2) Explain what's wrong, (3) State exactly what you want instead.

Bad iteration: "This doesn't work. Make it better."

Good iteration: "The form submits successfully but doesn't show a success message. Add a toast notification after line 47 that says 'Settings saved' and clears after 3 seconds."

Bad iteration: "Add error handling."

Good iteration: "Add a try-catch around the API call on line 23. If it fails, set error state to 'Unable to load data. Please try again.' and show it in a red alert box."

20. The AI Blind Spot Map

Decides: What categories of problems to always check manually

When to use: Any AI-generated feature touching real users

AI writes code for a single user in a perfect vacuum, consistently missing the "invisible" systemic chaos.

AI has predictable blind spots across five categories:

1. Race conditions: Two users click at the same time—does data get corrupted?

2. Proper validation: Frontend validation exists, but does backend validate too?

3. Edge case handling: Empty arrays, null values, missing data

4. Security: Authentication checks, permission verification, input sanitization

5. Async logic: Promises, error handling in async operations, loading states

Build a habit of checking this manually as from experience I can tell you that AI misses these categories almost every time…

Example: AI builds a "delete account" feature. Check the blind spots:

Race condition: Can user trigger delete twice? Add request debouncing
Validation: Does it check if user is deleting their own account? Add permission check
Edge cases: What if user has active subscriptions? Add validation before delete
Security: Does it require password confirmation? Add confirmation step
Async: Does it handle database errors? Add error handling and rollback

Without this checklist, you ship code with security holes and broken edge cases.

Product Growth Models

Decide how to expand your product offering and what to charge for it

21. The Pricing Validation Test

Decides: Whether your pricing makes sense to buyers

When to use: Setting initial pricing or considering changes

Show your pricing tiers to 10 target users. If they can't choose a tier in 30 seconds, your pricing is broken.

The test reveals:

Can users self-identify which tier fits them?
Do they understand the value difference between tiers?
Are tier names clear (not cute)?
Do limits make sense?

Example of bad pricing:

Starter: $19/mo - "For individuals"
Growth: $49/mo - "For growing teams"
Pro: $99/mo - "For professionals"

User confusion: "I'm an individual but also professional. I'm not growing but I have a team of 2. Which tier?"

Example of good pricing:

Solo: $19/mo - Up to 5 projects, 1 user
Team: $49/mo - Up to 25 projects, up to 5 users
Business: $99/mo - Unlimited projects, unlimited users

User clarity: "I have 3 projects and work alone. Solo plan." Decision made in 10 seconds.

Key questions: Can users identify their tier based on concrete limits? Do tier names describe who it's for or how much they can do? Would you be able to choose if you were seeing this for the first time?

22. The Impact vs. Effort Matrix

Decides: Which features to build next

When to use: Feature prioritization and roadmap planning

True velocity is about aggressively filtering out "Low Impact, High Effort" traps that feel productive to build but deliver nothing to the user.

Plot every potential feature on two axes: User impact (low to high) and Development effort (low to high).

Four quadrants:

High impact, low effort: Build these first (quick wins)
High impact, high effort: Build these next (major features)
Low impact, low effort: Build if you have spare time (nice-to-haves)
Low impact, high effort: Never build these (time sinks)

Features under consideration example:

High impact, low effort:

Add password reset link to login page (1 hour, prevents 20% of support tickets)

High impact, high effort:

Build API for integrations (2 weeks, enables enterprise customers)

Low impact, low effort:

Add dark mode (3 hours, some users will appreciate it)

Low impact, high effort:

Build custom analytics dashboard (3 weeks, competitors exist, users won't switch for this)

Build in this order: password reset → API → dark mode when slow → skip custom analytics.

Key questions: Is this feature actually valuable or just fun to build? Can we get 80% of the impact with 20% of the effort? If we don't build this, will users actually leave?

23. The Five-User Interview Pattern

Decides: What users actually need vs. what they say they want

When to use: Planning new features or understanding why adoption is slow

Just five conversations focused on past behavior can reveal more actionable data than 1,000 surveys asking about future wishes.

The pattern:

How do you currently solve [problem]? (Reveals workarounds)
Walk me through the last time you did [task]. (Actual behavior)
What's frustrating about how you do it now? (Real pain points)
What have you tried to fix this? (Shows urgency)
If we solved this, what would you do differently? (Validates impact)

What you're listening for: Patterns across multiple users. If 4 out of 5 mention the same workaround, that's your feature opportunity.

Example: You're building a content calendar tool. User interviews reveal:

5/5 users currently use Google Sheets
4/5 users manually check LinkedIn/Twitter to see what competitors posted
5/5 users forget to repurpose content across platforms
2/5 users want AI writing assistance (not a pattern yet)

Result: Build competitive content tracking and cross-platform reminders. Leave AI writing for later because there isn't enough demand signal.

Key questions: Did they complain about a problem, or did they prove they are trying to solve it? Am I listening to the loudest user or the recurring pattern? Did I ask "would you use this" (bad) or "how do you do this now" (good)?

24. The One Metric Focus

Decides: What success metric this feature moves

When to use: Before building any feature intended to improve the product

Shipping code without a defined success metric is just recreational engineering.

Every feature needs one primary metric that defines success.

Shift from "Building" to "Solving":

Bad planning: "We're building a referral program because it would be cool."
Good planning: "We're building a referral program to increase new user signups by 20%. Success = 1 in 5 users refers someone."

More examples:

"Add onboarding tutorial" → Metric: Increase activation rate (users who complete first task) from 40% to 60%
"Build API documentation" → Metric: Reduce API-related support tickets by 50%
"Add social proof to landing page" → Metric: Increase conversion rate from 2% to 3%

Key questions: What specific metric will move if this works? How will we measure it? Do we have a baseline for that number right now? If the metric doesn't move, will we kill the feature or iterate on it?

25. The Pivot vs. Persist Framework

Decides: When to change direction vs. keep iterating

When to use: When growth stalls or user feedback is consistently negative

Abandoning a good idea because of bad execution is a tragedy, but polishing a product nobody wants it’s the fastest way to bankruptcy.

Pivot when:

❌ Users consistently say "I don't have this problem" (Problem validation failed).
❌ Free users like it but nobody will pay (Value proposition broken).
❌ Churn is high because the product doesn't solve a core need.
❌ You repeatedly hear "I'd use this if it did X instead" (Wrong solution).

Persist when:

✅ Users confirm the problem is real and painful.
✅ Some users are willing to pay but pricing/packaging needs work.
✅ Churn happens because of execution issues (bugs, missing features).
✅ You hear "I love this but wish it had Y feature" (Right direction, needs iteration).

Example: You built a project management tool for freelancers.

Pivot Signal: After 6 months, users say, "I don't actually need project management—I just work on one project at a time. I need invoicing." → Problem validation failure. Pivot to invoicing.
Persist Signal: Users say, "I love this but it's missing recurring tasks and a mobile app." → Execution issue. Persist and build the missing features.

Key questions: Are users complaining about bugs (fix it) or the concept (kill it)? Do they wish it worked better, or do they wish it was something else entirely? Is the refusal to pay about the price or the value?

26. The Feature Kill Switch

Decides: When to remove features that aren't working

When to use: Regular product audits and when considering feature expansion

Every unused feature is a permanent tax on your codebase that slows down every future deployment.

"Zombie" Feature Tax:

Maintenance Burden: You still have to debug, explain, and test code that nobody uses.
Interface Clutter: More buttons mean more confusion for new users trying to find the core value.
False Confidence: Usage metrics look healthy overall, but the engagement is diluted across 20 mediocre features instead of 3 great ones.

Kill Switch Process:

Identify: Flag features used by < 5% of users in the past 30 days.
Investigate: Is it broken, hidden, or just useless?
Announce: Give users 30 days notice to save their data.
Delete: Remove the code entirely.
Listen: If nobody complains, you just made your product better.

Example: Monthly Feature Audit

Core workflow: 100% usage
Export to CSV: 65% usage
Custom templates: 45% usage
Bulk actions: 25% usage
Custom emoji reactions: 3% usage → Kill this
Calendar view: 2% usage → Kill this

Key questions: Does this feature pay rent? If we deleted this tomorrow, would our support inbox actually notice? Are we keeping this because it adds value, or just because we already wrote the code?

This is a lot. You don't need to memorize all 26 models right now.

Think of this as your 2026 reference guide. Bookmark it and come back when you're facing a specific decision, like: should I build this feature, how do I price this, is this AI code production-ready, which feature matters most?

The mental models you use most often will become instinctive.

The Gold Nugget 💡

Here's how to actually use these mental models: use the 5-Minute Product Think framework.

Before you prompt AI or write any code, spend five minutes asking which mental models apply. Write out 3-5 questions based on those models. Use the answers to guide what you build.

Copy-paste ready template:

text

Before I build [FEATURE]:
1. Product Validation: Is this a hair-on-fire problem or nice-to-have?
2. User Experience: What does the empty state show and what action should users take?
3. Technical Decision: Is this core to my value or should I use a third-party service?
4. What could go wrong: What edge cases will break this in production?
5. Success looks like: What metric moves if this feature works?

Adapt the questions based on which models fit your situation.

Building a new feature? Use product validation and UX models.

Reviewing AI code? Use the AI review checklist and good enough threshold.

Choosing your tech stack? Use build vs. buy and complexity budget.

This framework works because it forces product thinking before code thinking. It catches misaligned expectations when changes cost nothing and gives AI better context for what you actually need.

Let me show you this in action with a real scenario:

You're thinking of adding social sharing to your app. Five-minute product think:

Hair-on-fire problem (Model #3): Are users actively asking to share? Check support tickets and interviews. Result: Nobody mentioned sharing in the last 50 conversations. Not urgent.
Jobs-to-be-done (Model #6): What job would sharing solve? Maybe: "Get my teammates to sign up." But is that really how B2B tools spread? Result: Direct invites probably work better than social sharing.
Build vs. buy (Model #11): If we build this, use a library or write custom? Result: Social sharing libraries exist, but...
Impact vs. effort (Model #22): High or low impact? Low (nobody's asking). High or low effort? Medium (2-3 days with testing). Result: Low impact, medium effort = don't build.
One metric (Model #24): What metric would this move? Signups? But we get 90% of signups from SEO and direct outreach, not social sharing. Result: Won't move our key metrics.

Decision after 5 minutes: Skip social sharing. Build the team invitation feature instead (users actually asked for this).

See how the models work together? You prevented wasting 3 days building something nobody needs.

When to skip this: Quick experiments, throwaway prototypes, learning exercises, anything that won't touch real users.

When it's essential: Features that real users will interact with, technical decisions that affect your architecture o product changes that impact revenue.

The five minutes you spend thinking through mental models saves hours of building the wrong thing. And hours of debugging the right thing built wrong.

Let's Connect

Which of these 26 mental models do you wish you'd known about six months ago?

Or what product decision are you facing right now that could use a mental model? Reply and tell me. I read every response and often turn common questions into future articles.

Build With Better Judgment

Bookmark this page. Use it all year. Come back when you're facing a decision and not sure how to think it through.

You'll still build fast with AI but now you'll just build the right things.

Mental models are how experienced builders think. Now they're how you think too.

This post was originally published as the 26 Mental Models to Build Better Products in 2026 in my VSL Substack publication.

How to Prompt AI for Consistent JSON Responses

cucoleadan — Tue, 02 Dec 2025 14:03:05 +0000

This was originally posted on the VSL Substack publication.

You just used AI to generate your API integration code, tested it locally, and deployed it to production because it seemingly worked perfectly. Two hours later, your logs are filled with parsing failures and users cannot complete actions because "Invalid JSON" errors are popping up everywhere. The AI gave you working code, but the problem is that it only worked in your controlled test environment with your specific input.

It happened to me so many times I lost count, so I’m going to share one of the best ways to get your AI to generate valid json, every single time.

Bad JSON Means High Costs

When you are building features that depend on structured data like API integrations, database operations, or configuration files, JSON consistency directly determines whether your app works or breaks. A single malformed response can quickly cascade into hundreds of failed user actions, corrupt database writes, and support tickets flooding your inbox.

While AI generates JSON that looks correct during development, production environments expose inconsistencies like missing commas, trailing commas in strict parsers, unescaped quotes in user-generated content, and Unicode characters from international users. These small formatting errors crash entire features, so you need AI to output valid and production-ready JSON consistently instead of just succeeding in your local tests.

The Airport Security Model

Airport security examines your documents multiple times at check-in, security, and the gate because mistakes are expensive to fix later. JSON validation works the same way because AI generates structurally sound JSON in controlled conditions but often breaks under real-world variance. That’s why you need to build multiple validation checkpoints to catch these errors.

Most builders stop at the prompt, but production-ready apps require five distinct checkpoints to ensure reliability.

The Most Common Ways AI Breaks Your Data

Syntax Errors: Missing or extra commas, brackets, or quotes break JSON.parse() immediately on your server. For example, AI often adds a trailing comma after the last object property or forgets to close a nested object properly. While some lenient parsers might handle this, standard Node.js or Python backends will throw an exception and crash the request before your logic even runs.

Escaped Character Traps: One of the most insidious errors occurs when AI double-escapes characters inside the JSON string itself (e.g., returning \\" instead of \"). This technically creates a valid string but invalid JSON content for your parser, causing it to fail when processing fields that contain quotes, backslashes, or special characters.

Structure Mismatch: This happens when you get valid JSON in the wrong shape, such as receiving {"title": "My Article"} when you actually need {"article": {"title": "My Article"}}. Your backend code expects nested objects but receives flat structures, which causes undefined property errors that can take down your entire API endpoint.

Type Confusion: AI sometimes returns strings when you need numbers or arrays when you need objects. This results in valid JSON with broken logic. An example is when a count field comes back as "25" (string) instead of 25 (number), which breaks database schema validation and any math operations you perform on that data.

Truncated Responses: When you request a large dataset, some models will hit their output token limit and cut off the JSON mid-stream (e.g., ending with ... or just stopping). This leaves you with an incomplete, unparsable string. The reliable fix is to request data in smaller chunks—generating multiple subsets and concatenating the results in your code rather than asking for one massive payload.

The 5-Checkpoint Framework for Bulletproof JSON

1. Be Explicit in Your Prompt

Don't say: "Return the SEO data as JSON"

Say: "Return ONLY valid JSON with no additional text. Use this exact structure: {"title": string, "description": string}"

2. Provide a JSON Schema

The most reliable way to get consistent JSON structure is to give AI an exact schema to follow.

JSON Schema defines the structure, types, and requirements for your data. Instead of describing what you want in natural language, you provide a formal specification that eliminates ambiguity.

Add this to your prompt:

"Return JSON matching this exact schema. Do not add any fields not in the schema. All required fields must be present:

{
  "type": "object",
  "properties": {
    "title": {
      "type": "string",
      "maxLength": 70,
      "description": "An engaging, SEO-friendly article title"
    },
    "description": {
      "type": "string",
      "maxLength": 160,
      "description": "A concise summary of the article content"
    }
  },
  "required": [
    "title",
    "description"
  ],
  "additionalProperties": false
}

Why this works: Schemas eliminate type confusion and structure mismatch because the model validates its output against the schema pattern during generation. The additionalProperties: false flag is particularly powerful because it strictly forbids the AI from hallucinating extra fields you didn't ask for. This catches errors before they reach your code. Learn more about schema properties at the OpenAPI Schema specification.

3. Request Code Fences

Add to your prompt: "Wrap the JSON in markdown code fences with json syntax highlighting"

This prevents AI from adding explanatory text before or after the JSON because extra text breaks parsing when you extract the response.

4. Validate Before Using

Never assume AI output is valid. Always wrap in try-catch:

try {
  const data = JSON.parse(aiResponse);
  *// Use data here*
} catch (error) {
  console.error('Invalid JSON from AI:', error);
  *// Handle the error gracefully*
}

5. Check Structure After Parsing

Valid JSON doesn't guarantee correct structure:

function validateSeoData(data) {
  if (!data.title) return false;
  if (typeof data.title !== 'string') return false;
  if (typeof data.description !== 'string') return false;
  return true;
}

Red Flags: What to Watch For

🚩 AI adds explanation text before or after JSON: This breaks parsing. AI models are trained to be conversational and often add context before JSON blocks, so you must always request "ONLY valid JSON, no additional text."

🚩 Nested objects are inconsistent: AI formats the first object correctly but makes errors in deeply nested structures. The model's attention weakens as JSON depth increases, which leads to malformed brackets and missing commas three or four levels deep.

🚩 Numbers as strings: AI often wraps numbers in quotes because it sees numbers as text tokens rather than numeric types. You need to be explicit that "count should be a number, not a string."

🚩 Double-escaped characters in strings: AI returns \\" instead of \" for quotes inside strings because the model treats escape sequences as text patterns rather than functional syntax.

Watch Out For Escaped Character

One of the most frustrating JSON issues occurs when AI returns responses with escaped characters inside the JSON itself.

Example of what goes wrong:

What you expect: {"title": "The \"Best\" Guide"}
What AI sometimes returns: {"title": "The \\\"Best\\\" Guide"}

The AI double-escapes quotes, backslashes, and special characters. When you parse this JSON, you get literal backslash characters in your strings instead of properly escaped quotes. This breaks things when you try to display the data to users or pass it to other systems that expect clean strings.

How to prevent it:

Add to your prompt: "Use proper JSON escaping. Quotes inside strings should use single backslash escape ("), not double backslash (\")."

Hidden Edge Cases

Trailing commas: AI adds commas after the last item in objects or arrays. Strict JSON parsers reject this immediately even though JavaScript often accepts it, so this breaks in production environments using different parsers.

Unescaped special characters: If your data contains quotes or backslashes, AI often forgets to escape them. A title like "O'Brien's Guide" will break your JSON when AI returns "title": "O'Brien's Guide" instead of "title": "O\'Brien's Guide" if your parser is strict about apostrophes.

Inconsistent null handling: AI randomly switches between null, "null", empty string, or omitting the field entirely. Your application logic assumes one pattern but receives variations, which causes conditional checks to fail unpredictably.

My Production Safety Net

You have likely spent an hour debugging a critical failure only to discover the culprit was a single missing comma. In production, that one missing comma is not just a syntax error. It represents hundreds of failed user requests and corrupted data that piled up before you even noticed the issue.

Here's the technique that changed everything for me:

Use jsonrepair to automatically fix malformed JSON.

import { jsonrepair } from 'jsonrepair';

try {
  *// Try parsing normally first*
  const data = JSON.parse(aiResponse);
} catch (error) {
  *// If parsing fails, attempt repair*
  try {
    const repairedJson = jsonrepair(aiResponse);
    const data = JSON.parse(repairedJson);
    console.log('JSON repaired successfully');
  } catch (repairError) {
    console.error('Could not repair JSON:', repairError);
    *// Handle the error*
  }
}

The jsonrepair library automatically fixes common JSON formatting issues like adding missing commas, removing trailing commas, fixing unescaped quotes, and repairing truncated JSON.

Think of it as insurance. You hope you never need it, but when production breaks at 2 AM, you will be grateful it is there. And don’t ask me how I know that…

Tool of the Week: Zod

Zod - TypeScript-first schema validation

Once you have valid JSON from AI, you still need to validate that the structure matches what your app expects. Zod lets you define schemas and validate data in one line. TypeScript validates types at compile time, while Zod validates data at runtime.

Example:

import { z } from 'zod';

const SeoSchema = z.object({
  title: z.string().max(70),
  description: z.string().max(160)
});

*// Validate AI output*
const result = SeoSchema.safeParse(aiData);
if (!result.success) {
  console.error('Invalid structure:', result.error);
}

It catches structure mismatches and type confusion instantly, so pairing it with jsonrepair gives you bulletproof AI output handling.

Final Thoughts

Valid JSON is boring until it breaks production at the worst possible time. Build the checkpoints now and thank yourself later.

Let's Connect: What's your strategy for handling AI-generated structured data? Do you validate everything, or trust AI until it breaks? Reply and tell me about the weirdest JSON error you've debugged.

This was originally posted on the VSL Substack publication.

How To Architect A Feature In 5 Minutes Before Talking To AI

cucoleadan — Tue, 25 Nov 2025 14:51:09 +0000

This post has been originally published on my Substack publication VSL

Yesterday I opened my server logs and saw my API costs had spiked for no obvious reason.

I was building a new feature and thought I'd be clever. I told the AI: "Just reuse the logic from the other generator." The AI said "Sure!" The UI worked perfectly when I tested it.

But I never looked at what was happening underneath.

The AI had built something that made three separate calls to my server every time a user clicked one button. The feature worked on my screen, but it was costing me money with every click and making users wait longer than they should.

AI Will Make Anything Work Even if It's Wasteful

One of the first things you’ll learn building with AI tools is that they'll make anything work on the surface, even if it's wasteful underneath.

When you ask AI to build a feature, it assumes everything will go perfectly. It assumes your backend is already set up exactly right. That you don't care how many times it calls your database or how long users have to wait.

It assumes you know what you’re doing.

AI is incredibly fast at writing code but it doesn't think about what happens when that code runs in the real world, with real users.

That’s why you have to treat AI like a brilliant junior developer who will take shortcuts whenever you aren't watching. Here’s what you need to know to actually make it work.

The 5-Minute Sketch That Saves Hours

Spend 5 minutes thinking before you start typing prompts.

Before you ask AI to build anything, draw what you actually want to happen. I’m talking about the data flow, basically what information moves where, and in what order.

When I saw those cost spikes, I stopped. I grabbed a piece of paper and drew what the AI had actually built. It was a mess of arrows going back and forth.

Then I drew what I actually wanted:

Browser calls the API;
Server gets the request;
Server computes and routes my message;
Server calls the AI and saves the result in the database;
The browser polls my database and shows the new information.

Once I saw it on paper, the problem was obvious. The AI was calling the save step twice and re-fetching data that was already in database. It tried to reuse logic from an old feature that worked differently.

This Is The Classic "Reuse this code" Trap

I was building a Meta Description generator for Yahini. I already had a Brief Generator that creates meta titles and descriptions along with a bunch of other content analysis and writing the brief.

I thought I'd be smart. I told the AI: "Repurpose the Brief Generator logic, but just return the meta title and description."

The AI obliged. The feature worked. Users could generate meta information.

But here's what I didn't notice: the AI kept all the calls from the Brief Generator, then throwing all of it away and only showing the meta title/description.

I was paying for a full brief generation every single time someone just wanted a meta description. That's like ordering a full meal at a restaurant, eating only the dessert, and throwing the rest away.

My prompt started with *reuse this to…* without thinking about what this actually did.

This is why the 5-minute sketch matters. If I'd drawn what I wanted before prompting and share it with the AI, it would have seen immediately that the Brief Generator did 10 steps and I only needed 3 of them.

4 Questions to Ask Before You Prompt

Run through these 4 questions for 5 minutes before you prompt and your AI code will most certainly be more reliable.

Think of these as your architecture checklist. I use these symbols to mark my sketch:

🚩 Red flag: What will break your feature
✅ Green flag: What makes it production-ready

1. What goes in?

Be specific about what data you're sending and what format it's in.

🚩 Red flag: Vague descriptions like "user data" or "form values" leave too much room for AI to guess wrong.

✅ Green flag: Write exactly what the user provides: "A URL (text), a tone choice (dropdown with 3 options: professional, witty, casual), and their user ID (number)."

Example: Instead of telling AI "handle the signup form," say: "User enters email (must include @), password (minimum 8 characters), and checks a newsletter opt-in box (yes/no)."

2. What happens to it?

Trace the complete path your data takes from start to finish.

🚩 Red flag: Skipping steps like "validate" or "check permissions" because they seem obvious—AI won't assume them.

✅ Green flag: Map every hop: "Browser → Server validates URL format → Server scrapes website → Server sends scraped text to AI → AI returns description → Server saves to database → Server responds to browser."

Example: For a contact form, map the full path: "Server checks email is valid → Server checks for spam → Server saves to database → Server sends confirmation email → Server responds 'Message sent' to browser."

3. What could slow this down?

Think about external dependencies and what happens if they're slow or unavailable.

🚩 Red flag: Assuming external services (website scraping, AI APIs, payment processors) will always respond instantly.

✅ Green flag: Identify each external dependency and set realistic timeout expectations: "Scraping might take 5-10 seconds. AI call usually takes 2-3 seconds but could take up to 10."

Example: For a feature that checks if a domain is available, note potential delays: "Domain lookup calls an external API—it might take 3 seconds or fail completely if the service is down."

4. What happens when it breaks?

Think through (almost) every way this could fail and what the user should see.

🚩 Red flag: Only planning for the "happy path" where everything works perfectly.

✅ Green flag: List specific failure scenarios and responses: "If scraping fails → show 'Couldn't access that website, try another URL' and don't charge credits. If AI times out → show 'Taking longer than expected, try again' and don't save partial results."

Example: For a file upload feature, plan for: "File too large → 'Maximum 5MB.' Wrong file type → 'Only PDF, DOC, or TXT files.' Upload interrupted → 'Upload failed, please try again' and clean up partial files."

Example time

Let's say you're building a feature that generates social media posts from a blog URL.

Before you prompt AI, spend 5 minutes on this:

Draw your data flow on paper:

User pastes blog URL and picks platform (Twitter, LinkedIn)
Your server fetches the blog content
Your server sends content + platform to AI
AI returns optimized post
Your server saves it and shows it to the user

Mark your 4 questions on the sketch:

What goes in? Blog URL (text, must start with http), platform choice (dropdown: Twitter/LinkedIn), user's account ID
What happens? Browser → Server validates URL → Server scrapes blog → Server sends to AI with platform context → AI returns post → Server saves → Server responds
What could slow it down? Blog scraping might take 5-10 seconds if the site is slow. AI usually responds in 2-3 seconds. Total: plan for 15 seconds max.
What breaks? Blog URL invalid → show "Please enter a valid URL." Scraping times out → show "Couldn't access that blog, try another." AI fails → show "Generation failed, try again" and don't save anything.

Now you're ready to prompt AI. Your prompt might look like:

"Create an action plan on how to build an API endpoint that takes a blog URL and platform choice (Twitter or LinkedIn). First validate the URL format. Then scrape the blog content with a 10-second timeout. Send the scraped content to OpenAI with context about which platform. Return the generated post. If scraping fails, return error message without calling OpenAI. If AI fails, return error without saving. Only save successful results to database."

The AI will build exactly what you sketched because you thought through the flow first.

**IMPORTANT -* Use this kind of prompt to generate a more comprehensive action plan and only then start coding. I use an Architect mode in Kilo Code that creates a To Do list and then my other agents implement each item from that list.*

Show AI a Picture, Not a Paragraph

Here's how I fixed my expensive feature in 10 minutes.

I grabbed my rough sketch and uploaded the photo to the AI.

My sketch showed:

~~Brief Generator (full flow with 10 steps)~~ ← crossed out
New simple flow: URL → Scrape → AI → Save → Return
Notes in the margin: "Only need meta description and title, skip other stuff."

My prompt was simple: "Rebuild this to match my sketch. Remove the extra steps."

The AI understood immediately. It rewrote the code, removed the wasted calls, and cut the delay in half.

💡 The pattern: A rough sketch beats a detailed text explanation every time.

What to include in your sketch:

Boxes for each major step (Browser, Server, Database, External API)
Arrows showing what data moves where
Notes about what to validate or check
Cross-outs showing what NOT to do
Timing notes ("10 sec timeout here")

You don't need perfect diagrams. You need clarity about what talks to what and in what order.

Architecture Means Deciding Before Building

When developers talk about "architecture," it sounds intimidating.

Architecture means deciding how the pieces of your feature will talk to each other before you build them.

No-code platforms make these decisions for you, usually poorly, especially when your prompts are vague. It’s up to you to orchestrate everything, and it’s easier than you think.

When you skip the architecture sketch, you end up debugging in production. A user clicks a button, something breaks, and you're digging through server logs trying to figure out which of the five database calls failed.

When you sketch first, you know exactly what should happen. When something breaks, you can trace the flow on your sketch and find the problem in minutes.

The sketch becomes your debugging map.

✅ The test: If you can draw it on paper in 5 minutes, you're ready to build it. If you can't draw it, you don't understand it well enough yet.

This Week's Discovery: tldraw

I usually just use pen and paper, but when I need to share my sketch or save it for later, I use tldraw.

It keeps that hand-drawn feel, which stops you from obsessing over making it perfect. And when you need to share your architecture with AI, you can export the sketch and paste it directly into your prompt.

The hand-drawn style actually helps by keeping you focused on the flow instead of making it pretty.

Let's Connect

Next time AI-generated code isn't working the way you expected, stop. Step away from the screen. Draw what you actually want to happen.

Did you discover a loop or redundancy you didn't know existed? Reply and tell me.

Build smart,

Dan

This post has been originally published on my Substack publication VSL

Your Landing Page Is Probably Over-Engineered

cucoleadan — Wed, 19 Nov 2025 09:42:19 +0000

This post has been originally published on my Substack publication VSL.

React is what most developers reach for first, wrapped in Next.js or Remix or just running through Vite.

That makes sense for products that behave like real apps, where the screen is constantly reacting to what the user does, but it quietly makes simple sites feel heavier than they should to be.

For most solo founders, the priority is a site that loads fast, feels snappy on cheap phones, and plays nicely with AI crawlers and search engines trying to understand what you actually do.

Imagine a landing page with a hero, three feature blocks, and an email signup form.

In a typical React setup, you are loading an entire framework just to make that form submit.

That often means shipping a bunch of useless JavaScript even though the page itself is mostly text and a couple of buttons.

This causes multiple issues, starting with visitors having to wait for JavaScript to parse before they can even scroll smoothly.

AI tools trying to summarize your site, or search engines like Google trying to index your copy, have to run your JavaScript first before they “see” your text.

That extra step can fail on slower devices, tighter crawl budgets, or when an AI assistant is racing through dozens of sites to answer a user's question about "simple task management tools."

How visitors and AI experience your stack

Picture someone on a train with spotty signal clicking your link.

They see your headline start to appear, then watch the layout shift three times as JavaScript loads, then wait for the "Sign Up" button to become clickable.

By the time the page finally loads, they have already spent a few seconds wondering whether your product will feel just as clunky.

Now picture an AI agent trying to figure out what your product does so it can recommend you to someone asking for help.

It lands on your site, waits for React to hydrate, tries to parse your state tree, and eventually gives up or grabs a half-rendered snippet that makes your product sound vague or broken.

React shines when the page is constantly changing based on what the user does: think dashboards, editors, or complex flows.

Marketing pages are different. They sit closer to a good PDF with a few buttons than to Figma or Notion. Their whole purpose is to help the visitor understand what you do and ideally take an action towards your conversion goal, be it to sign up or to download a resource.

React for apps, Astro for "reading"

The turning point for me was admitting that my main site behaves more like a magazine than an app.

People land there to understand the promise, skim through a few sections, maybe read a FAQ, and then decide if they want to try the product.

Astro fits that world because it builds pages as plain HTML first and then lets you sprinkle interactivity only where you truly need it.

The default experience puts content ahead of JavaScript, which lines up nicely with what search engines, AI crawlers, and impatient humans all tend to prefer.

For the product itself, React still plays a big role.

I use it heavily for real app features and tiny tools where it makes sense, often with AI helpers and Kilo Code (my lightweight editor setup) to move fast on more complex flows.

The site you hit first, the one where you decide if this thing is worth your time, stays much simpler and more focused on clarity than the app that sits behind it.

Hosting on Cloudflare Workers

Once the pages are built, they live on Cloudflare's network as static files.

You can think of this as uploading a folder of prebuilt pages to a network of cities around the world.

The setup is three steps: build your site, run one command to push to Workers, and you are done. I do have a Github action setup that does this automatically which I will share in a later edition.

Static files are cheap to serve (basically free), and backend only gets involved when there is something truly dynamic to handle, like a form submission or a webhook callback.

From a reader's point of view, the page shows up quickly from wherever they are, with no waiting for a single origin server halfway across the world.

From your point of view, it means one fewer thing to worry about, and one more piece of your stack that "just works" once you set it up.

From an AI crawler's point of view, it means clean HTML that arrives fast and makes sense without needing to execute a bunch of JavaScript first.

If something does go wrong, you’re usually looking at a small, specific piece of logic instead of a giant app server.

A tiny Astro example that shows the difference

Here is a concrete look at how a page can be mostly "just content" with one small interactive piece.

You do not need to understand every symbol. The key idea is that almost everything is plain HTML, and only one piece is interactive.

This example shows the file structure of a typical Astro page. The top section (between the --- marks) runs at build time to prepare variables. The middle section is your HTML template. The <Counter /> component at the bottom is the only part that ships JavaScript to the browser.

---

const title = "Ship your first version this weekend";
import Counter from '../islands/Counter.jsx';

---

<html lang="en">
<body>
<main>
<h1>{title}</h1>
<p>Describe your product in one clear paragraph here.</p>
<Counter client:load />
</main>
</body>
</html>

Here is what happens when someone visits this page:

The browser receives HTML immediately. Your headline and paragraph appear before any JavaScript downloads.
Astro sends one tiny script to wake up the <Counter /> component, because you marked it with client:load.
Everything else stays as plain HTML. No framework overhead, no hydration delay, no waiting for a bundle to parse.

Compare that to a React app, where the entire page waits for JavaScript to load before showing anything, and AI tools have to execute your bundle just to read your headline.

Why this matters for a landing page: Most of your page is static content. Your headline does not change based on user input. Your feature descriptions do not need React. Only the signup form or a demo widget might need interactivity, and Astro lets you load JavaScript for just that piece.

Why this stack matters for real people (and AI)

For readers, a fast site means less time waiting and more time deciding whether they trust you.

Most people never think about frameworks. They simply notice whether your page appears quickly on hotel Wi-Fi and whether it feels smooth on an older phone.

For AI assistants, clean HTML means they can actually understand what you do and recommend you when it makes sense.

When ChatGPT, Perplexity, or any other AI tool crawls your site, it wants structured content it can read in milliseconds instead of a React bundle it has to execute first.

Pre-built pages give AI the straight story, which means you show up in AI-generated answers instead of getting skipped for something easier to parse.

For search engines, clear, pre-built content is easier to crawl and understand.

Astro's style of building static pages plays nicely with this, and hosting them on Cloudflare's edge means the "fast page" story stays true worldwide.

For you as a founder, this split makes your life simpler.

React stays where its power actually pays off, inside your product, while your marketing site stays closer to a document you can reason about in an afternoon.

When something breaks, the stack is small enough that the issue usually lives in Astro, React, or a specific Worker instead of feeling like a maze.

I mention Yahini on the site as an example of this stack in action: Astro for content, React where it counts, and Cloudflare Workers to get it all to people and AI crawlers quickly.

That mix keeps things simple enough that when something breaks, you can usually trace the problem in one sitting.

This week's finds: Grok Code Fast 1 and serving markdown to AI crawlers

Grok Code Fast 1 has been quietly helping in the background. It is a coding-focused model built for speed and low cost, which means you can afford to iterate quickly instead of waiting for one "perfect" answer.

The best part is that you can fire off several quick rounds of prompting without worrying about your bill, things like: "draft this component," "simplify it," "make it easier to read," and treat it like a rapid feedback loop in your editor.

That makes it a great fit for experiments like "rewrite this page component for Astro" or "split this React widget into a tiny piece I can reuse elsewhere," where you mostly need many small tries instead of one giant brain dump.

For example, I used it to turn a React hero section into a simple Astro page, then asked it to remove anything that was not strictly needed for the first version. The whole experiment took about fifteen minutes and three iterations, which would have felt much slower with a heavier model.

I use Grok Code Fast 1 via Open Router, but you can also use it directly from Grok.

Serving markdown to AI crawlers with Cloudflare Workers is another small trick worth knowing about.

Someone on Reddit shared a setup where Workers detect AI crawlers (like ChatGPT or Perplexity bots) and serve them a clean markdown version of your page instead of the full HTML.

That makes it even easier for AI tools to parse your content, understand what you do, and recommend you when people ask questions your product can solve.

If you are already on Cloudflare, this is a tiny addition that can make a real difference in how AI sees your site. The setup involves checking the user agent string, then serving a simplified markdown response when it matches known AI crawlers.

Link: Using Cloudflare Workers to serve markdown to AI crawlers - Reddit post

Let's connect

Which page in your world is mostly words and a single call to action, but still runs through your full React setup?

Reply and tell me what it does and what you are using today, and I will suggest the smallest "content-first" version you could try without touching the rest of your product.

If you have already split your app this way, reply with "stack split" and tell me how it went, so I can include a few real-world examples in a future issue.

You do not have to pick between "I will just rent a platform forever" and "I need to become a full-time engineer."

One fast, simple, ownable website is often enough to start, and moving it off your full app stack might be the lowest-risk win you can grab this week.

This post has been originally published on my Substack publication VSL.

How to Search Beyond the Docs When Your Code Won't Work

cucoleadan — Tue, 28 Oct 2025 14:09:30 +0000

This post has been originally published on my Substack publication VSL.

Last week I started building the new project management feature in Yahini, which meant creating a table with advanced sorting capabilities. At first, everything looked perfect. The table loaded, the data showed up, and when I clicked the "Due Date" column header, it actually sorted the rows.

But something was wrong.

Tasks with due dates were mixing randomly with tasks that had no dates at all. The empty ones should've been sitting at the bottom of the list, out of the way, but instead they scattered throughout the entire table. It drove me nuts.

I tried fixing it five different ways. Asked Kilo (via Context7) to pull the TanStack Table docs. Read through the sorting guide. Tried every example they had. Nothing worked. After 45 minutes of this, I started questioning whether I'd completely misunderstood how table sorting was supposed to work.

Exa to the Rescue

On attempt six, I asked Kilo to use Exa to search for similar TanStack sorting issues. Instead of just looking over docs, Exa searches the whole web, including GitHub discussions, obscure blogs and reddit threads.

The AI came back with a GitHub discussion thread and two Stack Overflow posts. One discussion nailed it: "TanStack automatically pushes undefined values to the end when sorting, but it treats null as an actual value and tries to sort it."

That was the issue. Supabase returns null for empty date fields by default. JavaScript treats null and undefined as completely different values. TanStack's sorting knows what to do with undefined (push it to the bottom), but null gets treated like any other value and sorted randomly in the list.

The AI was smart enough to connect the dots. It read those discussions, saw that I was fetching from Supabase (thanks to the Kilo Code context), and suggested: "Your database is probably returning null. Convert it to undefined when you process the data."

The fix was one line:

due_date: task.due_date === null ? undefined : task.due_date

That's it. Simply check if the value is null and convert it to undefined. TanStack now knows to push those tasks to the bottom.

Five minutes later, sorting worked exactly how it should. Tasks with due dates sorted by date. Tasks without due dates stayed at the bottom where they belong.

Would've spent another hour manually Googling variations of "tanstack date sorting broken."

Make Your Coding Assistant Even Smarter

MCP (Model Context Protocol) is just a standard way to connect AI assistants to external tools. Think of it like giving your AI a phone and a library card. Instead of being locked in a room with only what it remembers, it can now call out for current information whenever it needs it.

This matters because every time you leave your editor to search for something, you break flow. Before I set up MCPs, I'd be coding, hit a problem, open a browser tab, read three Stack Overflow threads, maybe check the docs, then try to context-switch back to where I was in my code. That's 5-10 minutes gone, plus the mental energy to get back into the problem.

With MCPs, the AI does the searching while you stay in your editor. You're still in your code, still thinking about the problem, and the answer comes to you instead of you going to find it.

What Exa Adds to Your MCP Setup

I already use Context7 MCP for documentation. Context7 is great when you need the official answer. Think of API references and function signatures, basically the "correct" way to do something according to the docs.

Exa fills the gap that documentation doesn't cover: real-world implementations. It reads the entire web. Blog posts where developers explain edge cases. GitHub issues where someone hit your exact bug and posted their solution. Stack Overflow threads with working code. Even Substack posts where people share problems they ran into.

For the sorting bug, Context7 gave me TanStack's official sorting documentation. That told me how sorting is supposed to work in theory. Exa found the GitHub discussions about null vs undefined specifically. That told me how to fix my actual problem.

The AI reads what Exa finds, interprets it, then asks clarifying questions. When it saw those discussions about null values, it connected that to my Supabase setup and suggested the exact conversion I needed. I didn't have to piece together the solution myself, but rather used the AI to synthesize information from multiple sources and give me a working answer.

That whole debugging process took 15 minutes total. An hour saved on a problem that would've been painful to solve manually.

Exa Helped Me Migrate Yahini Too

When I moved Yahini's presentation website from Remix to Astro a few weeks back (full breakdown coming this Friday), Exa saved me from hitting every edge case the hard way.

I asked Kilo Code via Exa to find blog posts from people who'd done the same migration.

It pulled up five different posts.

One from someone who migrated a SaaS marketing site, another from a developer who documented every routing difference they found, and a third with deployment gotchas for hosting static websites on Cloudflare Workers.

Used those posts as my migration checklist. When I hit a routing issue with dynamic paths, I already knew how to fix it because someone else had documented the solution. When my build failed the first time, I recognized the error from one of those posts and knew exactly which config setting to change.

What would've been two days of trial-and-error turned into about six hours of focused work. More on this next week with the full play-by-play.

Setting Up Exa MCP

Takes about 1 minute in Kilo Code. (I wrote about it on my previous post)

Step 1: Sign up at exa.ai and grab your API key from the dashboard. Free account gives you $10 in credits. That's roughly 2k searches with 1 to 25 results.

Step 2: Open your MCP config file. In Kilo Code: Settings → MCP Server → Edit Global MCP (this applies to all projects) or Edit Project MCP (just one project). In Cursor: Settings → Features → Model Context Protocol.

Step 3: Add this configuration:

json{
  "mcpServers": {
    "exa": {
      "command": "npx",
      "args": ["-y", "exa-mcp-server"],
      "env": {
        "EXA_API_KEY": "your-exa-api-key-here"
      }
    }
  }
}

Step 4: Replace your-exa-api-key-here with your actual key. Don't commit this to GitHub if you're working on a public repo—keep your API keys in environment variables or a local config file.

Step 5: Restart your editor. Exa should now show up in your AI assistant's available tools list. You can verify this by asking Kilo "What tools do you have access to?" and checking if Exa appears. Or just look at the green dot beside its name in your MCP list.

Exa Pricing

$10 free credits to start. I've used maybe 200 searches building Yahini features over the past few weeks and am still a long way from hitting my free credit limit.

After that, roughly $5 per 1,000 searches. To put that in context: if you do 10 searches per day (which is a lot), that's 300 searches per month, or about $1.50. Compare that to one hour of stuck time where you're manually debugging, and the ROI is obvious.

How I Actually Use This

I run three MCPs together when coding for Yahini: Context7, Exa, and Supabase MCP (lets the AI query my database directly for debugging). Between the three, I can build most features without leaving my editor.

Here's my actual workflow when I hit a problem:

First, I ask Context7 for the official approach. "Pull the TanStack Table sorting docs" or "Show me the Supabase date handling API." This gives me the foundation.

Then, if that doesn't solve it, I bring in Exa. "Find examples of people sorting null values in TanStack" or "Search for blog posts about Remix to Astro migration." This gives me real-world solutions from people who've hit the same problem.

The AI synthesizes both. It takes the official docs from Context7, finds the practical implementations from Exa, and gives me a solution that actually works in production.

The combined theory with actual practice is what makes this setup powerful.

I still open browser tabs for some things. Visual design inspiration, testing how a feature feels in different browsers, reading long-form technical deep-dives. But for "how do I build this" or "why isn't this working," the MCP setup handles the research while I stay focused on code.

Not to mention the Architect mode in Kilo works 10 times better when given access to the web.

This Week's Discovery: shadcn/ui

When I built Yahini's task table (the one from the sorting saga), I started with shadcn's data table component. It gave me the basic structure, sorting UI, and loading states out of the box. Then I customized it to match Yahini's design.

shadcn isn't a component library you install via npm. You get the actual code dropped into your project. So when I needed custom styling for overdue tasks (red text, bold font, urgent indicator), I opened the component file and modified it directly. No CSS overrides fighting with library defaults. No digging through prop documentation hoping there's an onOverdue callback.

And they have an MCP server, which I had to try!

Check it out here → ui.shadcn.com

Let's Connect

What makes you leave your editor most often? Looking up UI patterns? Finding code examples? Debugging weird behavior that doesn't match the docs? Reply and let me know. Curious what would actually speed up your workflow.

Want to try Exa? Grab the free credits at exa.ai, drop that config into your MCP settings, and test it for a week. You'll know pretty fast if it's worth it.

If you enjoyed this post please consider following me here and subscribing to my newsletter VSL.

Kilo Code Changed How I Write Code and I'm Never Going Back

cucoleadan — Fri, 24 Oct 2025 13:26:29 +0000

Quick note: This article was first published on my Substack publication -> VSL

I had three browser tabs open: AI Studio, ChatGPT, and my code. Copy, paste, refresh, repeat. I was coding by committee and learning nothing.

Every time I needed help debugging, I'd switch tabs, explain the problem, get code back, paste it into VS Code, test it, find new bugs, then go back to the chat. I spent more time switching contexts than actually building.

Right now, vibe coders are stuck between two bad options:

pick an expensive platforms like Lovable that charge $25-$200/month and force you to use their code editor;
juggle separate AI interfaces that don't integrate with where you actually work.

Today I’ll show you the third and better way.

How I Started Coding Features In Yahini

I'd write a prompt in ChatGPT and Gemini, get code, copy it, paste into VS Code, test, find bugs, go back to the chat, explain the error, get new code, repeat. I'd spend 15 minutes just switching between tabs.

I even tried self-hosting an AI wrapper like Chatbot UI. One of those open-source chat interfaces you connect to your API keys to use multiple models in the same browser tab.

Spent a Saturday setting up Supabase, configuring environment variables, deploying to Cloudflare.

Got it working, had my own private ChatGPT/Sonnet/Gemini/Grok basically. But it was still a separate tab. Still copy-pasting code between the chat and VS Code. And now I had to maintain it. Database migrations, updates, auth issues. Gave up after two weeks because it didn't actually solve the problem.

These approaches keep AI separate from your code. With platforms like Lovable or Bolt, you don't even get to choose your AI model. They pick for you, mark it up, and you pay whatever they decide.

BYOK Changes Everything

Kilo Code is an open-source VS Code extension with specialized modes:

Architect (plan before you code),
Code (generate features),
Ask (understand existing code),
Debug (fix issues).

Instead of asking ChatGPT in another tab, Kilo Code sits next to your code like a pair programming partner. It can automatically reference files, use MCP servers and compress the context when it becomes too large.

But nothing beats the bring-your-own-keys (BYOK) functionality.

I use OpenRouter with Google Vertex credits. I have one API key in Kilo Code that points to OpenRouter. Then inside OpenRouter, I add all my provider keys. Anthropic, OpenAI, Google, whatever.

I create different model configs in OpenRouter and switch between them based on task complexity.

Simple task? Cheaper model. Complex refactor? Claude Sonnet. All through one key.

I also added a couple hundred dollars in OpenRouter credits to have a backup in case I run out of credits on other platforms. These credits also allow me to test specific new models like the Grok Code Fast 1 without depositing funds into individual providers.

Now think of this, Cursor and Lovable charge anywhere from $20 to thousands of dollars per month.

With Kilo Code, I pay $0 for the tool (it's open source). Then I only pay for whichever AI model I use at provider rates.

Last month: $119 in API calls for 117 million tokens.

Disclaimer: This includes some of Yahini’s usage besides coding. If I were to approximate I would say that I spent ~$50 for coding which includes a complete migration of the Yahini.io website from Remix to Astro.

Building an API Endpoint in 2 Hours

I needed an API endpoint for Yahini's lead magnet downloads. Captures email, queues it for processing, triggers email sequence. Built with Hono and Cloudflare Workers.

I opened Architect mode and said: "I need an API endpoint that handles lead magnet downloads with email capture and queue processing."

Architect mode (powered by Sonnet 4.5) created a to-do list:

Set up POST endpoint with Hono routing;
Add anti-spam and rate limiting middleware;
Add request validation (email, resource ID);
Queue message for email worker;
Batch processing with delays;
Error handling and retries.

Then I switched to Code mode. It followed the to-do list Architect created to complete each step. The Cloudflare documentation MCP was also a huge time saver. I used it to give Kilo Code access to all the Workers docs, queue setup, and batch processing patterns, making sure the AI won’t hallucinate too much.

Here's the simplified version of the worker:

import { Hono } from 'hono'
import { antiSpam } from './middleware/antiSpam'
import { rateLimiter } from './middleware/rateLimiter'

const app = new Hono()
const api = new Hono()

*// Apply anti-spam and rate limiting middleware*
api.use('/download-resource', antiSpam)
api.use('/download-resource', rateLimiter)

api.post('/download-resource', async (c) => {
  const { email, resourceId } = await c.req.json()

  *// Validation*
  if (!email || !resourceId) {
    return c.json({ error: 'Missing required fields' }, 400)
  }

  *// Queue email for processing*
  await c.env.EMAIL_QUEUE.send({
    to: email,
    subject: 'Your Resource is Ready',
    templateData: { resourceId },
    requestId: crypto.randomUUID()
  })

  return c.json({ success: true })
})

app.route('/api', api)

export default {
  fetch: app.fetch,

  async queue(batch, env) {
    console.log(`Received batch of ${batch.messages.length} messages`)

    const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms))

    for (const message of batch.messages) {
      await delay(50)

      try {
        await handleSendEmail(message.body, env)
        message.ack()
      } catch (error) {
        console.error('Failed. Retrying:', error.message)
        message.retry()
        throw error
      }
    }
  }
}

Validation, anti-spam, rate limiting, and queue processing. Nothing fancy, but production-ready.

Took 2 hours total to have a fully functional worker. I ended up integrating it in my dedicated Brevo Worker to keep things organized. And Kilo Code helped with that too.

Why Kilo Code Beats Platform Lock-In

The platform trap is real. Lovable charges $25/month minimum for 100 credits, but here's the catch: those credits burn fast. A simple "Add authentication" prompt costs 1.2 credits. Building a landing page? 2 credits. You're looking at 50-80 prompts per month before you need to upgrade.

Bolt isn't better. Their Pro plan starts at $20/month for 10 million tokens, but developers report burning through 7-12 million tokens just fixing simple errors. One user lost 1.3 million tokens in a single day. And those tokens don't roll over.

But the real problem isn't the cost. It's that you don't own anything.

With Lovable or Bolt, you're building inside their editor. Sure, Lovable added GitHub sync (which is huge), but you're still paying a monthly subscription just to access the platform. When credits run out mid-build, your work stops until you top up. When a new model drops that's perfect for your use case, you can't switch to it unless they support it.

And here's the part nobody talks about: Lovable Cloud. That's their backend service, powered by Supabase. It has completely separate billing. You get $25 free per month, but once your app needs real data storage, authentication, or file uploads, that meter starts running. People build prototypes thinking they're spending $25/month, then their app gets traction and suddenly they're getting surprise bills for backend usage they didn't budget for.

Kilo Code separates the tool from the cost.

The extension is free. Open source. You install it in VS Code (also free) or even in Cursor if you're already paying for that. Then you bring your own API keys.

Here's what that means in practice:

Want to use Sonnet 4.5 for complex refactors? Pay Anthropic's API rates directly.
Found a free model that's great for simple tasks? Use that.
Got Google Vertex credits? Code for free until they run out.
New model drops? Switch to it immediately.

No subscription. No credits that expire. No separate backend billing. Just pay for the AI you actually use, at the rates the providers actually charge.

Even if you're already paying for Cursor ($20/month), adding Kilo Code means you control which models you use and when. Cursor's credits burn fast when you're in Max Mode. With Kilo Code, you decide if a task needs an expensive model or if a cheap one will do. You're not locked into their usage tiers.

Quick Note on Credits

I'm running Kilo Code with free Google Vertex credits routed through OpenRouter, so I'm basically coding for free until those run out. I'll write a full post on how to set that up.

For now, just know BYOK means you can use whatever credits or pricing you want. Free model for learning? Go for it. Paid premium model for production? Your choice. You aren't locked into anyone's credit system.

This Week's Discovery

The Cloudflare Documentation MCP made building that endpoint smooth. Instead of opening docs in another tab, Kilo Code had all the queue syntax, Worker config, and routing info right there. Saved me 30 minutes of tab-switching. If you're building on Cloudflare, this MCP is essential.

https://github.com/cloudflare/mcp-server-cloudflare/tree/main/apps/docs-vectorize

Let's Connect

What's your setup? Juggling AI chat tabs? Paying for Cursor or stuck in Lovable? Reply and tell me.

Want to try Kilo Code with BYOK? GitHub repo: https://github.com/Kilo-Org/kilocode. If you want the full OpenRouter + free credits walkthrough, let me know. I'll write that in the upcoming editions

Own your tools. Control your costs. That's how you stop paying rent on your own work.

Subscribe to my Substack publication VSL and follow my journey where I show how I build Yahini and what tools I use!