Shipping Cowpin with Opus 4.7 + Cursor — What Actually Changed

There's an old rule for solo founders: pick one product, ship it, iterate until it works or you give up. Scope creep and side quests are how you end up with a half-built product and zero customers.

I'm building Cowpin — the Pinboard-style bookmark manager you're reading this on — and the last year changed what "solo shipping" feels like. This post is an honest accounting of what actually changed with AI-assisted development, and — importantly — what these tools don't fix.

The old constraints (still real)

The "stay focused" rule wasn't superstition. It came from real limits:

• Context-switching is expensive. Losing the mental model of your codebase costs hours every time you come back cold.
• Bug-fixing is reactive. A production incident pulls you off the roadmap at the worst possible moment.
• Setup time amortizes badly. Spinning up a new feature after weeks away means "where was I?" before you write a line of code.
• Quality work has a fixed time cost per feature. Tests, a11y, edge cases — one human only has so many hours.

I used to start side projects and watch them die quietly in private repos. Cowpin is what I'm choosing to push through that pattern.

What actually changed

Two specific things, in 2024 and 2025:

1. Claude Opus 4.7 (or whatever frontier model you prefer) crossed a usefulness threshold

Earlier AI coding assistants were good for autocomplete, decent for boilerplate, and unreliable for anything architectural. Opus 4.7 (the model that helped shape this post) is meaningfully different:

• It can hold a whole feature in its head — schema → tRPC procedures → Vue components → tests — and produce all of it in one coherent pass.
• It can do non-trivial refactors across multiple files without losing the thread. The Pinboard build needed to extend the User model with username/bio/publicProfile fields and update validation in 3 places — Opus did all of it in one go.
• It will push back when you ask for the wrong thing. When I suggested something that would have blurred product boundaries on the main site, it argued against it for several paragraphs (correctly). This kind of pushback used to require a senior engineering colleague.
• It can read documentation, understand context, and apply it to your specific stack, instead of pattern-matching to generic examples.

The shift isn't "AI writes my code." It's "AI is a tireless mid-level engineer with infinite patience who happens to have read the docs for every framework I might use." That's not the same job description, but it's still a lot of leverage.

2. Cursor (or Aider, or Continue) closed the integration gap

The model is half the story. The IDE matters as much.

A model in a chat tab is helpful but high-friction:

• You copy-paste code in
• You copy-paste responses out
• You manually apply the diffs
• You catch the inevitable hallucinations
• You re-prompt because the model doesn't know your file structure

Cursor (and similar tools — Aider for the terminal, Continue, Cline) collapses all of that. The model sees your full repo. It runs commands in your terminal. It applies its own edits. It checks lint errors and fixes them. It opens PRs. The friction-to-leverage ratio dropped 10x.

Concrete example from the past week: the Pinboard feature in this codebase is roughly 35 files: 13 tRPC procedures, 2 Nitro routes, 6 Vue pages, 4 components, plus i18n + schema changes. End-to-end, it took about two evenings of focused work — not because I'm a 10x engineer, but because I was driving Cursor + Opus and the iteration cycle was "describe → review → adjust" rather than "write → test → debug."

Pre-AI, that same feature would have been a solid two-week sprint for me. Probably three.

That's a 5–7x speedup on the coding part of building software.

The new math

If coding gets 5x faster, and the rest of the work — distribution, sales, support, planning — stays the same speed, the bottleneck shifts.

Old bottleneck: engineering hours. Solution: ship in tighter loops.

New bottleneck: human-judgment-required work — talking to users, designing pricing, deciding what to build next, deciding when something is "done enough to ship."

The interesting part: you can spend that freed time on validation and distribution instead of only on more features — or you can mistake velocity for progress and build the wrong thing faster. The tool doesn't choose for you.

What AI coding does NOT fix

This is the section I most want you to read. AI coding makes the implementation part faster. It does nothing for the parts that actually determine whether a product succeeds:

It doesn't find product-market fit

No model on earth can tell you whether anyone wants what you're building. You still have to talk to users, ship rough prototypes, watch what people actually do. Opus can scaffold your landing page in 20 minutes; it cannot tell you if the words on it are persuasive to your target customer. That's still a job for a human, ideally one who's slept on it.

It doesn't do distribution

The single hardest problem for an indie product is "who knows you exist." AI can help draft a blog post (this one is mostly written by humans, with Opus suggesting structure and catching repetition), but nobody reads posts that have no audience pointing at them. The distribution work — building an audience, posting consistently, talking to communities, writing the right threads on the right platforms — is still 100% on you.

If anything, AI makes this harder, because content production has gotten so cheap that the noise floor has risen sharply. Standing out requires either real depth or real personality — both of which are exhausting, and neither of which AI provides.

It doesn't make hard decisions

I've been in conversations with Opus where I asked "should I do A or B?" and it gave me a thoughtful, balanced answer that I had to override based on gut. AI is excellent at laying out trade-offs. Choosing among them is still a human responsibility — and pretending otherwise is a recipe for inconsistent products.

It doesn't replace deep work

A codebase that the AI wrote at 5x speed still needs a human who deeply understands it. When something breaks at 2am — and it will — you don't get to debug at 5x speed by spinning up another Opus session. You have to actually know your own code. I make a point of reading every diff before I accept it, and I write the architectural decision myself before I let Opus implement. Without that, you end up with a codebase you don't really own — and that's worse than no codebase at all.

It doesn't cure focus problems

This is the one most relevant if you're thinking "great, I'll build five products at once." Don't. AI made it cheaper to start things, which makes discipline harder, not easier. The temptation to chase a new idea when the current one gets hard is enormous.

The discipline now isn't "can I build this?" — it's "should I?"

How I'm actually working (concretely)

What's been working for Cowpin:

1. One codebase, one product. Clear scope, clear mental model — no parallel products splitting attention.
2. Shipping mode vs exploration. I try not to mix "big experimental spikes" with "small reliable releases" in the same week. Context cost is real.
3. Batching. Short sessions for triage and fixes; longer blocks for features that need deep focus.
4. AI as the maintenance layer. Reviews, release notes, drafts of user-facing copy, catching i18n mistakes. The boring 30% of running a product used to eat disproportionate time; now it takes less.
5. Public commitment. This blog is part of that — writing what shipped is cheap accountability.

What I expect to happen

Honestly? Cowpin might find a small but real audience of people who missed Pinboard. It might not. AI doesn't change the odds by magic — it changes how fast you can iterate toward product-market fit, if you're honest about what you're learning.

The hard parts of building a business were never the lines of code. AI shifted the cost of exploration. Exploitation — turning a working product into a real business — is still the same long work it always was.

TL;DR for time-poor readers

• Frontier models + a repo-aware IDE materially speed up implementation.
• The judgment work — distribution, validation, design, prioritization — is still on you, and it didn't get faster.
• Don't take better tools as permission to split focus across five ideas. Discipline matters more, not less.
• Cowpin might still fail. AI doesn't change that. It changes how quickly you can learn and adjust.

Either way, we'll keep shipping honestly from here.