Build, Don't Buy

For decades the default was to buy SaaS for everything outside your core. AI moved the line. Build the tools that carry your taste and compound into an operating advantage, dogfood them on your own work, and rent only the commodity plumbing. The things you build become the substrate you build the next thing with.

The Thesis

The classic "build vs buy" calculus assumed engineering time was the scarce resource, so the answer for anything non-core was almost always buy. A design system, an automation runner, agent infrastructure — you paid a vendor because building one would cost a team months. The Golden Age inverted that: a single person with AI now builds in an afternoon what used to take a team a quarter. When the cost of building collapses, the build/buy line moves, and a large class of tools that used to be obvious buys become better builds — because what you build you own, you can shape to your exact taste, and you can keep using to build everything after it. Source: User, 2026-06-13

Kevin's version is not "build everything." It is build the differentiated layer; rent the commodity layer; dogfood relentlessly. The discipline is in where you draw the line. Source: User, 2026-06-13

The Line

This is exactly the line Loop's own README draws: "Product logic deserves the custom code. Infrastructure plumbing should be rented whenever possible … Managed primitives are a feature, not a compromise, when they let us spend time on the [differentiated work] instead of undifferentiated ops work." Source: loop/README.md "Shipping beliefs", 2026-06-13 Buying a database is not a failure of nerve; building your own database to run a SaaS app is the failure. Build where building buys you taste and a reusable edge; rent where it only buys you maintenance.

Dogfooding Is the Whole Point

A tool you build but don't use is a portfolio piece. A tool you build and live inside is a multiplier. Each of Kevin's products is both shipped to others and used to build the next:

• Sigil builds the sites. The Dedalus website and the Agent Machines and Loop dashboards are built with Sigil's tokens, presets, and agent skills — instead of buying a component library and paying the "AItax" of generic output. The design system isn't bought; it's built once and then used to skin everything. Source: reticle-ui/README.md, 2026-06-13
• Agent Machines runs the fleet. Rather than renting a vertical agent-SaaS for each job (a code reviewer, a research bot, a news agent), Kevin builds the platform his persistent agents run on and provisions specialists from presets.
• Loop keeps the skills fresh. Instead of buying an automation product that needs babysitting, Loop is the operator desk that refreshes Kevin's own agent skills while he sleeps. Source: loop/README.md, 2026-06-13
• This wiki is the operating system. The knowledge base, automations, and skills that run Kevin's whole workflow are built, not subscribed to.

The pattern: build it, use it on real work immediately, let the use surface the bugs, and let each tool become a primitive for the next. Owned tools compound; rented tools give you parity and a recurring bill.

Why It Works Now

• Completeness is cheap. Boil the lake — the last 10% that made building uneconomical (tests, edge cases, polish) costs minutes with AI, so a self-built tool can actually reach production quality, not just demo quality.
• You can encode your taste. Constraints over context means a self-built system can carry your judgment as rails an agent follows, so "build it yourself" no longer means "and maintain it by hand forever" — the agent operates the thing you built.
• Ownership fuels the work. You pour everything into what's yours; a bought tool is someone else's baby. The motivation to make the tool excellent only exists when the tool is yours.
• Building teaches the base layer. Susan Zhang's "neolabs" critique is a caution about inherited infrastructure: teams that only compose on top of prestige-company scaffolding can miss the burden of making the lower layer exist. For Kevin, this does not mean rebuilding commodity primitives by reflex. It means personally building the differentiated layer often teaches constraints, failure modes, and taste that a bought surface hides. Source: X/@suchenzang, 2026-05-16

The Sell-Side Mirror

Build-don't-buy for yourself is the same coin as sell-the-outcome for everyone else. The tools Kevin builds to avoid buying SaaS are themselves shipped as public products (Sigil, Loop, Agent Machines are open source / live). What is undifferentiated commodity for the vendor you rent from is differentiated advantage for the builder who builds it — so the builder who builds for themselves often discovers the product worth selling. The decision to build instead of buy is also a decision about what you might one day sell.

The form this takes is Open Core. You don't have to choose between "build it yourself" and "sell it": open-source the framework so anyone can build and own it, and charge for the hosted, integrated, pre-configured version for everyone who'd rather not assemble it. Agent Machines is the example — an open-source persistent-agent framework (MIT) where you pay to spin up agent machines and persistent agents with integrations and configurations built in. The model mirror is Reflex: an open-source Python web framework ("you own everything you build") where you pay for the Cloud/Enterprise tier to deploy and get integrations like Snowflake wired in. The open framework is distribution and credibility; the hosted assembly is revenue. Source: User, 2026-06-15; reflex.dev/pricing, 2026-06-15

Anti-Patterns

• NIH everything. Rebuilding Postgres, auth, or a payment processor to "own the stack" burns the advantage AI gave you on plumbing with no taste payoff. The point is the line, not maximalism.
• Build and shelve. Shipping a tool you never dogfood. If you wouldn't use it on tomorrow's real work, you built a demo.
• Buy the differentiated layer. Outsourcing the one thing that should carry your point of view (your design language, your agent conventions) to a vendor's median defaults — the generic-output tax.
• Confusing "rent" with "give up." Renting commodity primitives is a multiplier, not surrender; search before building still applies — don't build what a one-line dependency already does well.
• Forgetting that good SaaS sells time back. Long Live Hard SaaS is why "build, don't buy" is not maximalism. If a vendor reliably absorbs bug discovery, maintenance, integrations, and operational risk for an undifferentiated surface, buying it is rational.

Connections

---

Timeline

• 2026-07-04 | Source-reviewed Susan Zhang's "neolabs" bookmark and added the inherited-infrastructure caveat: personally building the differentiated layer teaches lower-layer constraints that prestige scaffolding can hide. Source: X/@suchenzang, 2026-05-16
• 2026-06-15 | Extended the Sell-Side Mirror with the open-core form and linked it to Agent Machines: open-source the framework, charge for the hosted/integrated/configured product — mirror of Reflex (OSS Python framework + paid Cloud/Enterprise where Snowflake/Databricks integrations live). Source: User, 2026-06-15
• 2026-06-13 | Articulated by Kevin as a standalone belief: instead of buying SaaS the way people have for decades, use the products he builds (Sigil UI, Agent Machines, Loop) to build everything else. Filed as a philosophy; cross-linked to the Golden Age (builder-ethos), ownership, constraints-over-context, and the services-as-software sell-side mirror. Source: User, 2026-06-13
• 2026-06-22 | Added the hard-SaaS counterweight: buying maintained SaaS is rational when the vendor is absorbing product-time, bug-finding, and integration burden for a commodity surface. Source: raw/notes/saas-bug-moat-slack-thread-2026-06-22.md