If you’re not embarrassed by the first version of your product, you’ve launched too late. It’s one of the most repeated lines in startups, and for good reason. Waiting for perfect is how you die with an unshipped product and an empty bank account. Ship early, learn fast, be a little embarrassed. It’s a small price for speed.

I’ve never disagreed with the shipping part. What I’ve come to think is that the embarrassment was always aimed at the wrong thing.

The trade-off was real

For most of the history of software, trading quality for speed was a legitimate choice. Quality cost time and money you had now, and paid you back later. Your codebase stayed easy to change, edges didn’t come back to bite you, the bug backlog never accumulated. It was a long-term bet. And betting on a long-term return against a short-term deadline is a real gamble, because the deadline is certain and the future isn’t.

So teams discounted the future and took the near-term win. In the early days there’s a high chance that “later” will never come, so paying off the accumulated technical debt is a symptom of success. So shipping rough was a decent call. Not always, but people were evaluating the odds in front of them and choosing rationally.

I chose differently. From the day we started Cronofy, quality was the thing I wouldn’t move. Building a product I could be proud of motivated me. I’d also seen the sustainable speed of not compromising on quality, and knew how to deliver it fast. But that was a somewhat contrarian choice, made against a real cost. A conviction that in our case the return wasn’t as deferred as it might be for many. And so worth more than the market was pricing it at. It was a bet, and I was aware it was a bet and I was all-in.

Scope was always the honest lever

Here’s the sleight of hand that the shipping culture smuggled in, and I include my earlier self among those who didn’t see it clearly enough.

We talk about scope, time and quality as three levers you trade between. The iron triangle, pick two, and so on. But they were never the same kind of thing. Scope is the honest lever. Deciding to solve this problem and not that one is a clean choice. It doesn’t degrade what you ship, it bounds it. You say “we do this, we don’t do that yet,” and everything inside the line is whole. Narrow the scope and the thing gets smaller, not worse.

Quality was never that kind of lever. Trading it doesn’t bound the work, it compromises the work you already chose to do. Same scope, done worse. Those are different acts, and describing them both as “trade-off” was wrong. “We cut scope” and “we cut quality” came to sound equally reasonable, when one is drawing a line and the other is accepting rot.

That’s why you can ship something tiny and be proud of it. A thing that solves a problem for ten people, and solves it completely, because it works. That is not embarrassing. The embarrassing version was the one where the corners you cut were quality corners, and the tell was the embarrassment itself. You don’t feel sheepish about a clean scope decision you’d defend to a customer’s face. You feel sheepish about what you let slip through. The established thinking taught people to feel the right emotion about the wrong lever.

Knowing where the line is

All of which is easy to say and hard to do, because the line between scope and quality isn’t self-evident. Many engineers can’t reliably tell, in the moment, which one they’re actually cutting. I’ve been told that descoping work is a super power of mine. Likely stemming from over a decade of not compromising on quality, meaning I’m more practiced than most.

Faced with an edge case, an engineer’s instinct is to treat it as a quality bar: this input isn’t handled, therefore the work isn’t done, therefore it isn’t good enough. Follow that instinct far enough and “high quality” quietly comes to mean “handles everything”. That isn’t a quality standard at all. It’s uncapped scope behind a mask of quality. You talk yourself into believing every corner must be handled for the thing to count as good, and you end up with a wide, shallow product that does a great many things not-quite-well.

The mistake is thinking those are the same thing. They aren’t. A deliberately narrow slice, done completely, is high quality. A broad sweep of part-finished paths is not, no matter how many boxes it ticks. One shiny vertical slice beats a stack of crappy horizontal ones. The trick is knowing where to slice. Choose the 20% of inputs that support 80% of usage and implement those completely. That cuts scope, on purpose, for a known audience.

The skill, the one worth training because it doesn’t come for free, is telling the two apart. The test I keep coming back to is how it lands with the user. A bug is surprising, a limitation is only disappointing. When something looks like it should work and then fails, that’s a nasty surprise. It feels broken: a quality failure. When you decided in advance not to cover a case and said so, that’s a boundary, and it reads as “not yet”. Disappointing, maybe, but not a dent in quality.

The same missing capability can be either failure. Let something fail, invisibly or loudly, and you’ve shipped a bug. Handle the boundary, a plain “you can’t do that yet” or an option not presented, and you’ve shipped an honest limitation that leaves the perceived quality intact. The edge case you consciously descoped and handled gracefully isn’t a hole in the product. It’s the product declaring its own edges.

Rough software lies to you

There’s a defence of shipping rough that sounds strongest exactly where it’s weakest: the early days, when you’re still finding out whether anyone wants the thing. Who cares if it’s held together with string? It’s throwaway. You’re learning.

But rough software poisons the signal you built it to gather. If the thing is janky and people don’t come back, you cannot know why. You can’t tell whether the idea failed or the implementation did. A quality build of a small idea is a clean instrument. It renders your actual hypothesis, and the feedback you get is about the idea rather than the mess. Slop is a noisy instrument that lies to you about your own product.

The bet just got shorter

None of this was enough to overturn the trade while quality stayed expensive. A long-term bet against a hard deadline is a hard sell, however right it is in principle. The pragmatist had the stronger short-term hand, and short-term hands win companies the time to have a long term.

Quality has got a lot cheaper. And the payoff has moved. The cost of doing it right has collapsed to the point where it now pays in the short term too. Agentic engineering not only makes it easier to produce quality software, but practices like automated tests allow tomorrow’s agents to move forward faster too. The long-term bet became a short-term one. You’re no longer being asked to compromise your principles for your runway.

This means the thing that made the compromise on quality defensible is gone. Refusing to compromise on quality used to be a conviction. You were paying now for a return you might not live to collect. It doesn’t need conviction anymore. It’s become the rational option.

What it costs us anyway

I don’t want to pretend the discipline is free even now. We have a rule at Cronofy: no known bugs. If we know about it, we fix it. In practice that means occasionally stopping the line. Halting the thing we meant to ship to deal with something another team would have triaged into a backlog and quietly lived with.

It has a consequence people rarely connect to quality at all: we don’t publish a roadmap. A dated roadmap and a no-known-bugs policy are a promise you can only keep by lying. Commit to a feature on a date, refuse to ship it with known defects. One of those two has to give. We’ve decided in advance which one won’t. So we don’t make the commitment to a roadmap. That costs us. There are conversations where a prospect wants the reassurance of not just what they are buying into today, but what will be delivered in the next year. We can’t hand it over, and that can risk business but it isn’t a principle if there’s no jeopardy to it.

What we give instead is the direction. We’ll talk with complete confidence about where we’re going and why, because that doesn’t depend on defects. What we won’t do is sell a specific feature on a specific day, because for a company that doesn’t compromise on quality, that was never possible. We swapped the counterfeit certainty for the real one.

Scope is the one lever you have against time. Scope down as hard as you can. Ship something that helps ten people and that you’re proud of. Make the call and defend it to their faces. Feel nothing that resembles shame, it was a choice, rationally made. The only thing left worth being embarrassed by is shipping it broken and calling that speed.

Stop being embarrassed. There’s no longer a reason for it.