Three markets, one thesis

Most product decisions are defended after the fact. A founder wants to build a thing, so they assemble evidence that the thing should exist. We try to run the argument in the other direction: start from truths about a market that would still hold if every current vendor vanished tonight, and permit yourself only the products those truths force into existence.

This document is our working example. Three markets, one shared derivation, and the decisions that fell out of it. Where the evidence is someone else's, we say whose. Where Reddit was blocked to our research pass and Hacker News had to carry the load, we say that too. A method you cannot audit is a vibe.

Four axioms

Everything below derives from four claims we hold across every market we enter. They are falsifiable: any counterexample is worth more to us than a hundred confirmations.

1. Customers don't buy software; they buy the disappearance of a recurring chore. Nobody wants a ledger app, a mock-test portal or a code assistant. They want books closed, ranks improved, and pull requests merged.
2. Wherever a human works as the connector between systems, there is a wedge for an agent. Provided the output stays verifiable. The accountant re-keying Tally entries and the coach hand-scoring answers are both connectors.
3. Trust scales with verification, not with intelligence. Every product needs a sign-off layer a human or a machine can check. A smarter agent with no receipt is worth less than a dumber one with an audit trail.
4. At zero stage, distribution beats features. Each product ships one free artifact that is genuinely useful before it asks for money.

The pattern

Stated once, the thesis reads: remove the human who connects systems, replace them with a verified agent loop, keep an accountable check at the point of trust. Applied three ways:

The rest of this piece walks each market's irreducible truths and the decisions they force. If you only want the conclusion, it is the table above.

Case one: accounting

Three truths survive decomposition. N1: a company's books are a deterministic function of its money events — bank transactions, invoices, payroll. Filings and statements are pure derivatives; nothing else should exist as "work". N2: the historical cost of accounting is not computation. It is data capture and error recovery — chasing receipts, reconciling statements, re-keying between systems. Most of every fee goes here. N3: compliance deadlines are rigid and liability requires a licensed professional, so the correct architecture is agent does the work, accountant signs off. Software alone cannot sell "filed"; humans alone cannot be cheap.

The strongest external validation comes from Last Accounting Company (YC S26, Finland), whose own materials confirm N1–N3: one general ledger as the operating layer, sources in once, an agent doing the manual work, accountants signing off, $80M+ in transaction value processed. We took the structure, not the content: their gap is geography. They are Finland/EU-only, built around Procountor/Fennoa/Netvisor replacements. Nobody dominant applies the model to Indian SMBs — GST filings, Tally and Zoho Books ecosystems, e-invoicing mandates.

Derived decisions, each traceable to a truth: sell the outcome ("books closed and filed, daily"), never seats. Connect banks, Razorpay or Stripe, POS and the email inbox once; reconcile continuously; alert only on anomalies. Keep a named human accountant as signature and escalation path. Build one India-native feature no global player has: GSTR-2B input-tax-credit mismatch detection — credit lost because a supplier did not file, found and chased automatically. And the wedge artifact (axiom four): a free GST-readiness audit of a prospect's last quarter.

One deliberate negative decision: we will not build another ledger app for people who like their ledger app. Read-only integration with Tally and Zoho for switchers; replacement only for clients who want zero involvement. N1 says the books are a function of money events; it does not say everyone hates their accounting software.

Case two: exam preparation

India's government-exam prep market looks like a content market and is not. H1: the outcome is a function of syllabus coverage, practice- with-feedback quality, and long-horizon retention. Lectures serve none of these directly, and coverage is now free on YouTube. H2: the scarce resources are personalized feedback — especially Mains answer evaluation — and honest progress measurement. Those were expensive precisely because they required human graders. H3: prep spans one to three years; attrition is driven by unmeasured progress and isolation, not lack of videos. H4: aspirants distrust marketing but trust analytics computed from their own data. Self-generated data is the lock-in.

The derived product leads with the feedback loop, not content: Mains answers evaluated against published rubrics within minutes, percentile against a real cohort, a revision queue grown from the user's own errors, and a rank trajectory band updated after every mock. The trust move (axiom three) is calibration as brand — publish how often our projected band contained the real rank. No incumbent dares, because none measure it. The free artifact is a diagnostic mock with a weak-topic map.

Case three: coding agents

K1: a coding agent's value is P(first-shot correctness) times developer time saved; chat polish is secondary. K2: base models commoditize through the API; durable value sits in the harness — context assembly, safe file operations, and a verification loop. K3: "one-shot" must mean something operational: the process exits zero with tests green, or prints an honest failure report. Never a plausible half-change. K4: setup costs more than one command and one environment variable lose the audience.

K3 is the whole product. Competitors ship chat loops whose success is conversational; a merge gate you can run from cron needs a contract the exit code can carry. Hence Kestrel's rule — no success claim without a green verification step — and its honesty clause: if a task implies no verification command, refuse politely and suggest one. The free artifact is the open harness core.

What the method kills

A derivation is only honest if it vetoes things. Two scoped lab products exist because the same axioms cut against the common version of them. Orrery is not "an RSS reader with AI summaries" — models in the ranking path would violate verifiability; ranking is corroboration, independence and novelty, computed deterministically, and it dies if independent-source detection can't beat a precision bar. Latch is not "a notification manager" — it holds gig notifications mid-trip and ranks by rupees per effective kilometre, on-device, with no auto-accept, because the rider, not the app, must remain the accountable check. Both scope documents name the milestone that kills them. So should yours.

How we work

• Dossier before code. Every product gets a first-principles teardown with external evidence attached, stored next to the site source.
• Rules that must hold go in code, not prompts. A GST validation rule or a debit-equals-credit check is versioned code; the model may propose, it may not assert.
• Every product shares one harness discipline — the verified loop described in its own paper.
• Publish the misses. The blocked Reddit APIs and the dead ends belong in the same document as the wins, or the wins are worthless.

Companion pieces: the verified agent loop, the engineering pattern all three products share, and taste as a constraint, how the same discipline applies to what our software looks like.