How AI Built Almost All of Cowpin — Fast, and Where It Hit a Wall

Here's the uncomfortable thing I learned building Cowpin with an AI coding agent: the code was the easy part.

Cowpin is a Pinboard-style bookmark manager — the one you're reading this on. Over a stretch of days, an AI agent and I shipped a genuinely large feature set: a distraction-free reader, highlights and annotations, one-click export to Markdown/Obsidian, a full Pinboard-compatible API, a browser extension for Chrome/Edge/Firefox, a terminal CLI, semantic search, "ask your library," auto-archiving against link rot, and a latency rewrite that roughly halved page-load times. Each of those used to be a multi-day project on its own.

This is an honest accounting of what that felt like — the speed, and the wall.

The loop that changed the math

The workflow wasn't "AI writes code, I paste it." It was a tight, autonomous loop:

1. I describe the intent in a sentence or two.
2. The agent reads the relevant code, implements the change across the backend (tRPC + Prisma), the web app (Nuxt), and the mobile app — matching the existing patterns instead of inventing new ones.
3. It writes the tests, runs them, pushes, waits for the deploy, and verifies the change on production — minting a real session to check an auth-gated page, measuring the actual TTFB, curling the live endpoint.
4. It reports back what shipped and what it measured.

The unit of work stopped being "a feature" and became "an intent." Highlights across web and mobile — an afternoon. A Pinboard-compatible /api/v1/ layer so people's existing Pinboard tools keep working — a session. The whole thing stayed green: at one point a full run of the test suite was 319 tests passing across 79 files, after a dozen-plus changes in a row.

It caught bugs I would have shipped

The part that surprised me most wasn't the writing — it was the reviewing. The agent kept finding real defects, often ones a human would miss on a fast pass:

• The Pinboard posts/all endpoint was returning the wrong JSON shape (an object where the spec — and every real client — expects a bare array). Silent incompatibility, caught by reading the spec against the code.
• A rate-limiter that 429'd the first request because remaining: 0 was ambiguous between "just used your last one" and "over the limit."
• Bookmark favicons were being hotlinked from Google — leaking every saved domain to a third party on each page load. For a privacy-first app, that's exactly the wrong default. Now they're proxied and edge-cached.
• A domain redirect (cowpin.com → www) was silently stripping the auth header, so API tokens 401'd across the redirect.

None of these were crashes. They were the quiet, plausible-looking bugs that make it to production and erode trust. Having a tireless second reader that actually verifies claims against reality changed the quality baseline, not just the speed.

The wall: building was never the bottleneck

And then you finish. The product is complete, tested, healthy, and fast — and you have zero users.

Because everything the AI is great at — reading code, writing it, testing, deploying, verifying — turns out to be the part that was never actually scarce once you have a good agent. The things that stayed slow are the things a human still has to do, and most of them aren't code at all:

• Approvals. AWS denied our email-sending request twice (the first attempt described too many unrelated projects; reviewers want one clean use case).
• Config and DNS. Verifying a sending domain, wiring a payment provider, getting an extension through a store review queue.
• Judgment and taste. What to build next, what to not build, how to price, when to launch, what the headline should say.
• Distribution. The single hardest problem. A finished product nobody knows exists is worth exactly as much as an unfinished one.

AI collapsed the cost of building toward zero, and in doing so it made something obvious that was always true: shipping features was never the moat. Taste, trust, and getting in front of the right people were — and those are still, for now, stubbornly human.

So what does this mean for a solo builder?

It means the leverage is real but it points somewhere specific. Use the agent to erase the "I don't have time to build that" excuse entirely — because you don't, anymore. Then spend the time you got back on the parts it can't do: talking to users, making sharp product calls, and doing the distribution work that no model will do for you.

Cowpin is free while we're finding our first users — every feature, no limits. If you're leaving Pinboard or Pocket, import your whole library in about two minutes and tell me what's missing. That feedback is the one input I still can't automate — and the one that matters most.