The churn email was four lines long and entirely polite. They were not renewing. The team had enjoyed working with us. And then the sentence that took a while to stop thinking about: the output was fine, but the team had started pasting things into a general assistant instead because it was faster.

Not the output was wrong. Not it was too expensive. It was fine, and fine was available elsewhere at no cost.

That is the actual mechanism of slop, and it is not an aesthetic complaint. Slop is a commercial condition.

A definition that is actually useful

Slop is not bad output. Bad output is easy to detect and easy to fix, and customers will tell you about it loudly.

Slop is output that is fluent, plausible, competently structured and completely substitutable. It reads well. It is not wrong. It could have been produced by anybody with access to a general purpose model and ten minutes.

The distinguishing property is not quality. It is substitutability. That is why slop is a distribution problem: it does not damage your reputation, it damages your reason to exist. Customers do not leave angry. They leave the way that email left, politely, having found the same thing on a shorter path.

Three places it lives

In the product. The dangerous property here is that product slop does not hurt acquisition at all. Acquisition is driven by the promise, and the promise demos beautifully. Slop hurts retention, exclusively and on a delay, which means your dashboard looks healthy for two quarters and then does not. If your churn is concentrated at the four to six month mark among engaged users, this is the first thing to check.

In the codebase. Yesterday’s subject. Code that is syntactically clean, passes linting, compiles, and encodes no judgment about the system it lives in. It is the same failure in a different medium: plausible, fluent, undifferentiated, and expensive later.

In the marketing. The most common and the least examined. Content production used to be a genuine moat because it was expensive: you needed writers, editors, subject knowledge and time. All of that collapsed. Which means volume is no longer an advantage, because your competitor has the same collapse available to them.

Publishing a great deal of competent, undifferentiated content in 2026 is paying for noise. Worse, it trains your audience that your name is attached to things not worth reading, which is a hard association to undo.

The substitution test

There is one exercise I recommend to everyone and almost nobody wants to run.

Take ten real tasks from real customer usage. Have somebody outside the product team complete them twice: once with your product, once with a general purpose assistant and a well-written prompt. Then show both sets of results to a customer without telling them which is which.

You are not looking for a win. You are looking for whether they can tell. If they cannot reliably distinguish the two, your differentiation lives entirely in convenience and interface, and you should read Lesson 5 again before spending another quarter on features.

Most teams avoid this test, and the avoidance is itself informative. It is a cheap experiment with a high information yield, which is exactly the profile of an experiment people skip when they suspect the answer.

What the opposite looks like

Four properties, and they are all consequences of decisions rather than of model quality.

• It is specific to this customer. Their data, their history, their naming conventions, the constraint they mentioned in month two. A general model cannot produce this because it does not have the inputs. This is the data asset from Lesson 5 doing its job.
• It knows what it does not know. Output that flags uncertainty, declines to guess, or routes to review when the confidence is low. This is genuinely difficult to build, it is what an accountable product does, and it is the property customers cite most often when explaining why they trust one tool over another.
• It is short. Slop is verbose because verbosity is free and length signals effort. Concision requires a decision about what matters, and a decision about what matters requires knowing the domain. Length is the most reliable surface indicator of undifferentiated output.
• It encodes an opinion. Somewhere in the product there should be a judgment you made about how this work should be done, which a general tool would not make because it has no stake in the outcome. That opinion will lose you some customers. It is also the reason the others chose you.

Three ways this goes wrong

You respond to slop by adding features. The instinct when retention softens is to ship more. If the underlying problem is substitutability, more features produce a larger substitutable product. The fix is depth in one place, not breadth across five.

You measure satisfaction instead of substitution. Satisfaction scores stay high right up until the churn email, because customers are satisfied. They are just also indifferent, and no standard survey question distinguishes those two states. Ask instead what they would do if you disappeared on Monday. The answers cluster into we would have a serious problem and we would manage, and only one of those is a business.

You let volume stand in for differentiation in your marketing. Publishing five undifferentiated pieces a week costs you time, budget and reputation, and returns nothing that compounds. One piece a month containing something only you know, because you operate the product and see the data, is worth more than all five, and it is the thing that gets cited rather than skimmed.

We won that customer back eventually, though not with the same product. What changed was that the output started carrying information from their own history that a general tool had no way to reach. It was less impressive and considerably harder to leave.

If a model can produce your output, it will produce your competitor’s too. Sell the part it cannot.

Monday: the golden set, and how you find out your product got worse.

The pull request was fourteen hundred lines across nine files. The description said add user flow. It was approved four minutes after it was opened, by somebody who was in a meeting at the time, and it went to production that afternoon.

Nothing bad happened. That is the important part. Nothing bad happened for about eleven weeks.

I want to be careful here, because there is a lot of moralizing about this subject and most of it is written by people who are not shipping anything. The productivity gains are real. Teams report forty to sixty percent improvements on bounded tasks and I believe them, because I have seen it. The problem is not the tool. It is that a tool designed for exploration keeps getting promoted into a role it was never designed for, and the promotion happens silently.

What the data actually says

The most careful measurement available comes from an analysis of two hundred and eleven million lines of code changed between 2020 and 2024 across repositories at large technology companies. Two findings matter.

Copy-pasted code rose from 8.3 percent of changed lines to 12.3 percent, a relative increase of roughly half. Over the same period, refactored lines fell from around twenty-five percent to under ten percent. In 2024, for the first time on record, copy-pasted code exceeded refactored code.

That inversion is the whole story in one statistic. Refactoring is how a codebase stays comprehensible. Duplication is how it stops being comprehensible. The tools made it cheaper to add and no cheaper to consolidate, so the ratio moved, and it moved in the direction that compounds.

A separate study of around eight million pull requests found technical debt rising by thirty to forty percent after teams adopted AI coding tools. And in a detail I find quietly telling, the researcher who coined the term vibe coding in early 2025 had, by early 2026, publicly described it as past its moment and shifted to advocating a model with substantially more human oversight in the loop. The phrase did not survive its first year before its inventor moved on.

Where the line goes

The useful framing is not whether to use these tools. It is which code is allowed to be produced this way.

Generate freely. Interface components, internal dashboards, one-off scripts, data migrations you will inspect anyway, test fixtures, prototypes, anything you intend to throw away, anything with no access to production data. This is the majority of code by volume and the speed gain here is close to free.

Never without dedicated review and automated analysis. Authentication. Authorization, which is a separate and more frequently broken thing. Payment handling. Anything touching personal data. Anything that writes to production. Anything that decides what a user is allowed to see.

The failure modes in that second category are boringly consistent. Across incidents reported through 2025 and into 2026, the same handful of causes recur: databases left open by default configuration, row-level security never enabled, keys hardcoded into code that reaches the client, backend services exposed without authentication. None of these are exotic. All of them are the kind of thing that a generated solution produces because it satisfies the request as stated and nobody stated the rest.

The ninety-day reckoning

There is a recognizable arc and it runs on roughly a quarterly clock.

Weeks one to four, velocity is extraordinary and everybody is delighted. Weeks four to ten, small inconsistencies accumulate: three different ways of handling errors, two competing patterns for the same operation, functions that do four things because it was easier to extend than to separate. Around week ten to twelve, the first incidents arrive, and they are hard to diagnose because nobody wrote the code and the person debugging it is reading it for the first time under pressure.

By day ninety, teams commonly report spending twenty to thirty percent of sprint capacity on defects traceable to generated code. The velocity gain from month one is gone. Then it goes negative, because every subsequent change is harder in a codebase nobody trusts.

This is now a market. Rescue engineering, the business of taking a product that was built quickly and rebuilding it into something maintainable, is a recognized specialty with recognized pricing, commonly quoted between fifty thousand and five hundred thousand dollars depending on how long the product ran before somebody looked underneath it. Of the several thousand startups that shipped production applications using these tools through 2025, a large majority reportedly needed some form of partial rebuild or rescue work within the following year.

The cost is not the rebuild. The cost is the six months you spend doing it instead of building.

The protocol that actually works

Five rules, and none of them require slowing down much.

• Somebody must be able to explain it. This is the only rule that really matters. If nobody on the team can explain how authentication works without opening a chat window, you do not have authentication. You have an arrangement that has not yet been tested.
• Cap diff size on anything sensitive. A fourteen hundred line change is not reviewable and everybody knows it, which is why it gets approved rather than read. Small changes get read.
• Static analysis on every path that handles credentials, permissions or personal data. Automated, in the pipeline, blocking. This costs nothing per run and catches the recurring failures listed above.
• Write the tests by a different route than the code. Generated code validated by generated tests derived from the same description will agree with itself confidently. Specify the tests from the requirement, not from the implementation.
• Keep your junior engineers and give them maintenance work. This one is strategic rather than tactical. The people who will be able to maintain generated systems in two years are the people who spend this year reading and modifying code they did not write. That is exactly the work that is being automated away from them, and teams that eliminate it are removing the pipeline for the skill they will most need.

We did eventually go back and read the fourteen hundred line change. It was mostly fine. It also contained a permission check that ran on the client and not on the server, which meant the check was a suggestion. Finding it took an afternoon. Finding it after somebody else had would have taken considerably longer and involved a lawyer.

You can ship code you do not understand. You cannot run a company you do not understand.

Tomorrow: the churn email, and the three kinds of slop.

The runway model is one tab in one spreadsheet and there is exactly one cell in it that anybody actually looks at. Everything else exists to produce that cell. It contains a month and a year, and once you have seen it you cannot unsee it.

For a long time I treated that cell as the deadline. It is not the deadline. It is roughly six to nine months after the deadline, and confusing the two is how founders end up negotiating from a position where the only honest answer to how much runway do you have is a number that makes the terms worse.

The real deadline is earlier than the cell

Raising money takes time. Building a list, first meetings, partner meetings, diligence, documents, close. Three months is fast. Six months is normal. Longer is common and not a sign of failure.

You also cannot raise well with two months left. Investors ask, you answer, and the conversation changes shape immediately. Not because anyone is cruel, but because a company that must close in six weeks has a different set of options than one that could walk away, and everybody in the room understands that.

So the working deadline is the money-out month minus the fundraising duration minus a buffer. If your cell says November and raising takes five months, your real deadline is around April, with the assumption that you will not be building product in April. Founders consistently discover this in month three of a raise.

The twenty-month problem

There is a specific timing assumption baked into a lot of seed-stage plans and it has quietly stopped being true.

The median gap between closing a seed round and closing a Series A has stretched considerably, on recent measures to around twenty months. That is a substantial change from the twelve to fifteen month planning assumption most founders inherited from earlier cohorts, and it is not a temporary market condition so much as a rise in the bar. Series A now expects repeatability, typically somewhere in the range of one to three million in annual recurring revenue with evidence that acquisition can be repeated rather than recounted.

The arithmetic follows. If you raise a seed and plan twelve months of runway to reach a Series A that on average arrives at twenty, you have planned a crunch and scheduled it for a moment when you will also be trying to sell. Plan for twenty-four to thirty months, which usually means either raising more or spending less, and spending less is the option you control.

Two clocks, running at different speeds

Here is the modeling error I see most often, and I made it myself: one burn number.

An AI company has two kinds of burn and they behave nothing alike.

Headcount burn. Salaries, contractors, the tools people need. You control it completely. It moves in steps, because hires are discrete events. It is sticky in the downward direction, both practically and morally. It is almost perfectly forecastable, which is why finance people love it.

Compute burn. Inference and everything metered per request. Your customers control it. It moves continuously, it is only partly forecastable, and its defining property is that it rises when things go well.

Blend those into one line and you get a number that is wrong in both directions. It understates your risk in a good month and overstates it in a quiet one.

The scenario worth modeling explicitly is the uncomfortable one. Growth accelerates. Usage deepens. Compute burn rises immediately, because inference is consumed the moment the work happens. Revenue lags, because you invoice monthly or quarterly and business customers pay on their own schedule, which is thirty to sixty days after that. For a period of weeks, sometimes months, your runway is getting shorter precisely because you are winning. Nobody who learned software finance in the subscription era expects that shape, and it has caught out companies whose only mistake was growing quickly.

The number investors will ask for

Growth rate on its own has stopped being a sufficient answer, because anybody can buy growth. The question now is what the growth cost.

Burn multiple is net cash burned divided by net new annual recurring revenue over the same period. If you burned two million and added two million of net new recurring revenue, your burn multiple is one. Below one is excellent and rare. One to one and a half is a good business. Above two needs an explanation, and above three needs a plan rather than an explanation.

It is a better question than growth because it is difficult to flatter. It captures pricing, retention, sales efficiency and cost of goods in a single ratio, and it penalizes exactly the behaviors that look like traction and are not.

Calculate it quarterly. Show it before you are asked, because a founder who volunteers their burn multiple is telling the room something about themselves independent of the number.

The question almost nobody calculates

If you never raise another round, and your current growth rate and current cost trajectory continue, do you reach profitability before the money runs out?

That is the whole question. It has a yes or no answer and it takes an hour to compute properly. In my experience most founders have never done it, and a meaningful number of them assume the answer is no when it is actually yes with two decisions changed.

What makes it valuable is not the answer. It is what it does to the conversation. A founder who knows they can survive without raising is negotiating. A founder who does not know is hoping. Investors can tell the difference within about ten minutes, and it is the single largest determinant of terms that founders treat as unchangeable.

Three ways this goes wrong

You model revenue as booked rather than collected. Signed is not invoiced, invoiced is not paid, and the gap between them is where small companies die with healthy-looking pipelines. Model cash, on the date it arrives, with realistic terms.

You cut compute instead of headcount, or headcount instead of compute, without checking which is which. Under pressure teams reach for the lever that is easiest emotionally rather than the one that is largest. Compute burn is frequently reducible by thirty percent or more through routing and context discipline, without anyone losing a job. That work should be done before any conversation about people, and it usually is not.

You update the model quarterly. Cost per query moves weekly, prices move, and one shipped feature can change your unit economics overnight. A runway model refreshed four times a year is a historical document. Monthly is the minimum, and the person who maintains it should be a founder, not somebody a founder asks.

Headcount burn you control. Compute burn your customers control. Model them separately.

Tomorrow: the pull request nobody reviewed, and the ninety-day reckoning that follows it.

The usage dashboard is a bar chart with one bar per account, sorted descending. The first time I looked at it properly, the tallest bar by a considerable distance belonged to somebody who had never paid us anything.

They were not abusing it. They were using it exactly as intended, enthusiastically, every working day, for a job they genuinely had. They were, in the language of the old playbook, a fantastic signal. They were also, in the language of the invoice from Lesson 7, our third largest cost.

This is the part of the AI business model that catches people who learned software economics before 2023, and it catches them somewhere around month five.

The free user used to be free

In classic software a free user costs a row in a database, some storage, and a fraction of a shared server. The marginal cost is genuinely close to zero, which is why the freemium model became near universal. You could carry a hundred thousand free accounts on the same infrastructure that served your paying ones and barely notice.

That is no longer true, and the change is not subtle. A free user in an AI product consumes inference on every request, at the same rate as a paying one, and there is no version of the architecture where that goes away. A heavy free account can cost you more per month than a median paying account generates.

The consequence is that a free tier is no longer a marketing decision with a rounding error attached. It is a spending program, and it belongs in the same conversation as any other spending program: what is it buying, how much is it costing, and how would we know if it stopped working.

What free is actually buying

There are three legitimate answers and you should be able to name yours in one sentence.

Distribution. Free users tell other people. This works when the product is visible in use, when the user has an audience, or when the output carries your name somewhere. It works poorly for internal back-office tools, which is most business software.

Data. Usage improves the product in a way that benefits paying customers. This is real, and it is the strongest argument, but it only holds if you are actually capturing and using the signal. A free tier that generates logs nobody reads is not buying data, it is generating logs.

Qualification. Self-service reduces the cost of finding buyers. The free tier does the first three sales calls for you, and the people who arrive at your pricing page have already decided. This is the most common real answer and the easiest to measure.

If none of those three describes what you are doing, you have a free tier because everybody has a free tier. That is a preference, not a strategy, and now it has a monthly cost attached to it.

Designing a loan rather than a gift

Five design choices do most of the work.

• Route free traffic to the cheaper model tier. The routing discussion from Lesson 7 applies with more force here. A quality difference that would be unacceptable in a paid product is entirely acceptable at a price of zero, and it can cut the cost of your free tier by most of it. Be honest about it in your documentation rather than hiding it.
• Cap by unit of value, not by time. Fourteen days of unlimited access rewards the person evaluating you least seriously, because the serious evaluator needs three weeks to get their data in order. Ten documents, or fifty runs, or one project is better: it survives a slow start, it maps to something the user understands, and it costs you a bounded amount.
• Rate limit, and show the limit. A visible counter is not a hostile act. It converts better than a silent ceiling because it tells the user what the paid version is for.
• Require something. An email address costs a user nothing. A work email costs slightly more. Connecting a real data source costs real commitment and filters hard. Ask for the largest thing you can justify at the point where the user is about to receive value.
• Measure it as a cohort and be willing to end it. Cost per free user per month, conversion rate by cohort, and time to convert. If a cohort has not converted in ninety days, it probably will not, and continuing to serve it is a decision you should be making on purpose.

The trial alternative

Freemium is not the only option and it is frequently the wrong one for business software with real serving costs.

A time-boxed trial of the full product, with payment details taken up front, does most of what freemium does at a fraction of the cost and with a far better conversion rate. Taking the card is not a trick, it is a filter, and the people it filters out were unlikely to buy.

The reverse trial is worth knowing about too: full functionality for a short period, then automatic downgrade to a genuinely limited free tier rather than a wall. The user has felt the good version and lost it, which is a much stronger motivator than never having had it, and your ongoing cost sits at the limited tier rather than the full one.

Three ways this goes wrong

You build a free tier that is good enough. The most expensive version of this mistake is not the compute bill, it is that you have shipped a competitor to yourself, staffed it, and given it away. If a meaningful share of your free users are getting the job done without paying, the tier is not a funnel, it is the product. Find the line where value becomes real and put the wall exactly there.

You underestimate abuse. A product that turns requests into money spent is an attractive target. Keys embedded in client-side code get scraped. Accounts get created in bulk. Somebody discovers your endpoint is a cheaper route to a frontier model than paying for one directly. This is not hypothetical, it is a normal Tuesday, and the defenses are ordinary: server-side keys, per-account and per-address rate limits, anomaly alerting on cost rather than on traffic, and a hard spend ceiling with somebody’s phone number attached.

You never calculate the cost per free user. It is one division and almost nobody does it. Total free-tier inference spend divided by monthly active free accounts. Put that number next to your conversion rate and your average contract value and you can answer, in about thirty seconds, whether the program is an investment or a habit.

We kept our free tier, narrowed it substantially, and routed it to a cheaper model. Conversion went up. That was not the outcome I expected and it is the one most teams report, which suggests the generous version was never doing the work we imagined.

Every free user is a loan you make in compute and hope to repay in conversion. Know the interest rate.

Tomorrow: the runway model, and the two clocks that run at different speeds.

The pricing page has three columns and the middle one is highlighted, because every pricing page has three columns and the middle one is highlighted. It took longer to agree than the architecture did, and unlike the architecture it could not be refactored quietly on a Thursday.

Pricing is the most consequential product decision most founders treat as a marketing decision. It determines which customers you attract, which ones you can afford to keep, what your salespeople argue about, and whether growth improves your margin or destroys it.

In a category where serving a customer costs real money per request, it also determines whether your most enthusiastic user is an asset or a liability.

Per seat is dying, and the reason is arithmetic

Seat-based pricing fell from around twenty-one percent of software companies to about fifteen percent inside twelve months. That is a fast move for something as sticky as a pricing model, and the cause is not fashion.

If your product means one person can now do the work that used to take ten, then per-seat pricing asks the customer to pay you in proportion to the number of people who did not get more productive. Your revenue falls as your value rises. You have built a machine that reduces the size of your own invoice.

Buyers worked this out quickly, and the more successful your deployment the faster they work it out. It is a difficult position to argue your way out of at renewal, because the customer is right.

Per seat is not dead. It remains sensible where the product augments a person who still does the job, where usage per person is roughly uniform, and where the buyer’s mental model is headcount. It is a poor fit for anything that completes work autonomously.

The four models and where each one wins

Per seat. Predictable for both sides, easy to forecast, easy to sell. Breaks when one seat can do ten seats of work, and breaks badly when consumption varies by an order of magnitude between users on the same plan.

Per unit of consumption. Charging by tokens, calls or compute. Natural for infrastructure and developer products where the buyer is technical and understands what they are consuming. In an application sold to a business buyer it creates billing anxiety, which is a real commercial problem: a finance team that cannot forecast your invoice will cap usage, and capped usage is capped value.

Per outcome. Charging when something measurable happens. Per resolved support conversation is now an established pattern at prices well under a dollar, and it has spread from support into sales and back-office work. The alignment is genuinely elegant: the vendor is paid when the thing works. The difficulty is definitional. What counts as resolved? Who decides when the customer disputes it? What happens when the model does eighty percent of the work and a human finishes it? Every one of those becomes a contract clause and eventually a support ticket.

Hybrid. A base subscription with an included allowance, plus overage above it. This is now the default. Adoption rose from roughly twenty-seven percent to forty-one percent in a year, and by some counts more than nine in ten AI software companies use some blended model with a consumption component in it.

The reason hybrid won is not that it is elegant. It is that pure models each fail in one direction. Pure subscription exposes you to the heavy user. Pure consumption exposes the customer to an unforecastable bill. Pure outcome exposes you to definitional argument and leaves money on the table with high-frequency users. Hybrid fails in none of those directions completely.

The rule

There is one principle underneath all of this and it is short enough to write on the wall.

The unit you charge for should be the unit that costs you money.

When those two diverge, the customer who loves your product most is the one damaging you most, and you find out at exactly the moment you would like to be celebrating. A flat rate plan with an unbounded heavy user is the clearest version. That account uses the product forty times more than the median, costs you real money on every request, renews without hesitation, gives you a testimonial, and quietly consumes the margin from six other accounts.

You do not have to charge per token. You do have to make sure that when consumption goes up substantially, revenue goes up too.

Designing the hybrid

Four components, and each one has a job.

• The base. It covers your floor: the cost of existing, the cost of operating, and the cost of serving the included allowance. If the base does not cover the allowance at full consumption, you have priced a loss and made it recurring.
• The included allowance. Size it so that the large majority of customers never exceed it. That matters psychologically more than financially. A customer who never sees an overage experiences your product as a predictable subscription, which is what their finance team wants, while the meter is still there for the ones who need it.
• The overage rate. Priced with real margin, not at cost. Overage is not a penalty and it is not a favor. It is the part of the model that keeps you solvent at the top of the distribution.
• A cap or an alert. Nobody should ever receive a surprise invoice from you. A notification at eighty percent of allowance and a hard ceiling that requires a decision to lift buys you more goodwill than any discount.

Three ways this goes wrong

You price against the trial month rather than year three. This is the mistake buyers make and vendors mirror. The cheapest model at low volume is frequently the most expensive at scale, and the reverse. What matters is the shape of the cost curve at projected volume: linear, sub-linear or step function. Model your own pricing at ten times current usage before you publish it, because you will live with the structure much longer than the numbers.

You adopt outcome pricing without being able to define the outcome. Outcome pricing is the most aligned model and the most operationally demanding. Before you commit, write the definition, write the dispute process, and write what happens in the partial case. If you cannot write those three paragraphs clearly today, you are not ready to sell it, and you will spend the first year arguing about invoices instead of selling.

You set it once. Willingness to pay moves. It rises as a category matures, as your product improves, and as the buyer’s alternatives get worse or better. Companies that grow well revisit pricing at least twice a year, deliberately, with data. Companies that set a price in month four and defend it for three years are leaving a great deal on the table and usually discover it during a competitive loss.

Charge for the thing that costs you money, or your best customer becomes your worst one.

Tomorrow: the usage dashboard, and the loan you are making every time somebody signs up for free.

The first model provider invoice arrived itemized by day. Thirty-one rows, most of them small, four of them not. The four large ones corresponded to days when we had been testing, which is to say to days when nobody was using the product at all.

What struck me was not the amount, which was trivial. It was the shape. This was a bill that moved with activity, and every previous software bill I had ever seen was a bill that moved with the calendar.

That difference is the whole subject. It is the reason an AI company is not a software company with a model attached, and it is the line item that quietly decides what business you are in.

Inference is cost of goods sold

Classic software runs at eighty to ninety percent gross margin because it is built once and the cost of serving the next customer rounds to nothing. Hosting is largely fixed and spreads across a growing base. That single fact produced two decades of business models, valuation multiples and hiring plans.

An AI product cannot do that trick. Every request spends real money. The marginal cost of the next customer is not near zero, it is a function of how much they use you.

The numbers now in circulation are consistent across sources and worth committing to memory. AI product gross margins are landing in the fifty to sixty percent band rather than the eighty to ninety percent band. One widely cited 2026 survey of several hundred software executives put the average AI product gross margin at 52 percent, up from 41 percent in 2024. Model inference accounted for somewhere around twenty to twenty-three percent of total AI product cost.

Read that last figure carefully, because the direction is the surprising part. Inference share rises as products mature. It does not fall. The intuition from classic software, where unit cost decays as you scale, is exactly inverted. You succeed, usage deepens, cost of goods grows as a proportion of the total.

A founder who assumes the old curve will build a plan in which margin improves automatically with scale. It does not. It improves with engineering, or it does not improve.

Cost per query, and why it is a weekly number

There is one metric that should be on a wall. Total inference spend for the period divided by requests served in the period.

Track it weekly, not monthly, because monthly is slow enough that a bad change ships, propagates and becomes normal before anyone notices. Early-stage products commonly sit anywhere from a fraction of a cent for a lightweight completion to fifteen cents or more for a multi-step agent run that calls tools and reasons across several turns. The spread across that range is enormous and it is entirely determined by choices you make.

When the number rises, there are only two explanations and both are worth knowing about immediately. Either you shipped a more capable feature without optimizing the path underneath it, or the amount of context being consumed per task has grown, usually because somebody added history, retrieved documents or examples to a prompt and it helped.

Neither is wrong. Both are decisions, and a decision you did not know you made is the one that shows up as a margin problem two quarters later.

The levers, in order of size

Routing. This is the largest lever by a wide margin and the one most teams reach for last. Within a single provider’s lineup the price spread between the cheapest capable tier and the most expensive frontier tier commonly runs five times or more per token. Most requests in most products do not need the top tier. Classify the incoming request, send the routine majority to the cheap tier, reserve the expensive one for the cases that genuinely need it, and measure quality on both. Teams that do this well route the large majority of traffic to inexpensive models and see no user-visible degradation.

Caching. Repeated context, whether system instructions, retrieved documents or conversation prefixes, does not need to be paid for at full rate every time. The mechanisms differ by provider and the savings on a workload with stable context are large enough to change the shape of a P&L.

Context discipline. The cheapest token is the one you never send. There is a common pattern where a retrieval step returns twenty documents, all twenty go into the prompt because it is easier, and three of them were relevant. Retrieval quality is a cost lever disguised as a quality lever.

Batching and asynchronous processing. Where the user is not waiting, work that runs on a delayed queue is materially cheaper. A surprising proportion of what teams build synchronously does not need to be.

Self-hosting. Last, deliberately. There is a crossover point where running your own inference beats paying per token, and it exists, but it arrives at volumes higher than most early companies reach and it brings an operational burden that a team of six should think hard about accepting. Do the arithmetic before the conversation, not during it.

Model three futures, not one

Unit prices for inference have fallen dramatically. Capability that cost roughly twenty dollars per million tokens from a frontier model in late 2022 was available at a small fraction of that by early 2026. Hardware rental rates for the relevant accelerators fell substantially across 2025 as well.

It is tempting to plan on that continuing. Do not plan on it exclusively. Build three scenarios.

In the first, prices keep falling at roughly ten percent a quarter and today’s fifty percent gross margin drifts toward seventy without you changing your pricing. That is the optimistic case and it is genuinely plausible.

In the second, prices hold flat. Your margin is whatever your engineering makes it.

In the third, your cost per unit of work rises even as token prices fall, because you shipped more capable features and the number of tokens consumed per completed task grew. This has been the actual experience of a lot of teams. Token consumption per task has risen by one to two orders of magnitude since late 2023 as products moved from single completions to multi-step reasoning with tool use.

If the business only works in the first scenario, that is important information and it is available today rather than in eighteen months.

Three ways this goes wrong

You put inference in operating expenses. It sits in cost of goods sold. Booked as an operating cost it disappears into a line with the design tool subscription, your reported gross margin becomes fiction, and you will not discover the error until somebody in diligence asks a question you cannot answer.

You measure the average and ignore the distribution. Usage in these products is heavily skewed. A small number of users generate a large share of consumption. An average cost per customer that looks healthy can conceal a handful of accounts that are individually unprofitable, and on a flat rate plan those are the accounts most likely to renew enthusiastically.

You optimize before you measure. The instinct to cut costs early is good and it is frequently spent in the wrong place. Instrument first: cost per request, per customer, per feature. Then optimize the thing that is actually large, which in my experience is almost never the thing anyone guessed.

In AI you do not discover your margin at year end. You design it at the start, or somebody else designs it for you.

Monday: the pricing page, and the rule that stops your best customer becoming your worst one.

The exercise took forty minutes and it was the worst forty minutes of that month. Write down ten companies that will buy this. Real ones, with names. Next to each one, write the job title of the person who signs, and how you get in front of them this week.

We managed four. Two of those were companies where somebody in the room knew somebody, which is a route to a meeting rather than a route to a market. The other six lines stayed empty for two days while we quietly moved on to more comfortable work.

Ten names on a whiteboard is a brutally efficient diagnostic. If you cannot fill it in, you do not have a segment. You have an adjective.

A market is not a segment

Small and medium businesses is not a segment. It is roughly thirty million companies in the United States alone, sharing nothing except a headcount band. Financial services is not a segment. Operations teams is not a segment.

A segment is a group where you can do three things. Name ten members without research. Describe how a purchase actually happens inside them, including who objects. Reach all ten within a week using channels you already have.

Everything failing those three tests is a category, and categories are useful for describing a business after it works. They are useless for finding the first customers, because you cannot send an email to a category.

The reason this matters more than it used to is that the cost of building the second product has collapsed while the cost of earning the second customer has not. A small team can now ship a startling amount of software. What it cannot do is be credible to eleven different kinds of buyer at once, and credibility is now the scarce input.

The wedge test

A wedge is narrow enough that you are not a choice, you are the obvious choice. If a buyer has to compare you against three alternatives on a feature grid, the wedge is too wide.

There are three dimensions to narrow along, and most teams only use the first two.

Who. Role, industry, size, and increasingly the regulatory regime they operate under. A company that must keep data inside a particular jurisdiction is a different buyer from one that does not, regardless of what they do.

What job. Not what department. A specific recurring task with a name the buyer already uses. If you have to teach them the name of the job before you can sell them the solution, you have added a step you will pay for in every conversation for two years.

What trigger. This is the underused one. What event causes somebody to look for this today rather than in eighteen months? A new regulation with a compliance date. An audit finding. A person leaving. A volume threshold crossed. A system being retired.

Products sold without a trigger are sold on the buyer’s timeline, which is indefinite. Products sold into a trigger are sold on the trigger’s timeline, which has a date on it. When founders describe a long sales cycle, the diagnosis is usually not the cycle. It is the absence of a trigger.

Design partners, and the pilots that go nowhere

The first handful of customers are not customers in the ordinary sense. They are design partners, and the relationship needs to be structured or it decays into unpaid consulting.

A design partner gives you access to real workflows, real data conditions, and honest feedback from people doing the actual job. In exchange they get influence over what gets built and a price that will not be repeated. What they should not get is the product for free, and this is the point most founders concede too easily.

Free is not a discount, it is a different product. A free pilot is evaluated by whoever has spare time. A paid pilot, even at an almost symbolic amount, requires somebody to sign something, which requires somebody to care whether it works. The signature is the signal, not the money.

This matters because the graveyard is well documented. Research through 2025 and into 2026 has repeatedly found that only a small fraction of enterprise AI projects, on some measures around one in twenty, ever reach production. The pilots do not fail because the technology disappoints. They stall because nobody owned the transition from interesting to operational, and no budget line existed for the second year.

So structure the thing. Three components, written down: what you will deliver and by when, what they will provide including data access and the hours of the person who knows the workflow, and a date on which it either becomes a real contract or ends. Pilots without an end date do not end. They fade, and you find out four months later from somebody’s out of office reply.

Why narrow wins in AI specifically

Focus has always been good advice. In this category it is closer to a structural requirement, for three reasons.

Evaluation is domain specific. You cannot build a meaningful test set for everyone. You can build one for invoice exceptions in a particular industry, and that test set is what lets you ship changes without breaking customers. A wide product cannot be evaluated, which means it cannot be improved with confidence, which means it degrades.

Data only compounds under repetition. The asset described in Lesson 5, the record of what was accepted, corrected and eventually proved right, only becomes valuable when the same shaped task recurs thousands of times. Spread across eleven use cases it is a pile of unrelated logs.

And accountability requires competence. If part of what you sell is standing behind the output, you have to understand the domain well enough to know when the output is wrong. That is not a claim you can make across four industries with a team of six.

Three ways this goes wrong

You widen after the first rejection. A prospect says no, and the instinct is to conclude the segment is wrong rather than the pitch. Widening feels like progress and is usually retreat. Ten rejections in one segment is data. One rejection in each of ten segments is noise.

You pick the segment you can reach instead of the one that has the problem. Access is a real advantage and it is not a substitute for need. Selling into your former industry because you have the contacts, when that industry does not actually have the problem acutely, produces a year of very friendly meetings.

You let the first large logo redefine the product. A big name arrives with requirements attached. Some of those requirements are the market speaking. Most are that company speaking. Distinguishing between the two is the single hardest judgment of the first year, and the test is whether the other nine names on the whiteboard would want the same thing.

You cannot be chosen by a market, only by a customer, so pick customers you can name.

Tomorrow: the first model provider invoice, and the line item that decides your business model.

We rewrote the one-page product definition eleven times. I know it was eleven because the file names went to eleven, and because somewhere around the seventh I stopped believing we would ever finish it.

Version one described a technology. It used the word platform twice and named three model capabilities. It was accurate and it was useless, because it did not say what anybody would stop doing if they bought it.

Version eleven described a job. Who does it today, how long it takes them, what goes wrong when it goes wrong, and what the company takes responsibility for. It was shorter, less impressive to read aloud, and it was the first version an engineer could build against and a salesperson could sell from.

The Monday test

There is one question that should be asked before any serious money or time is committed, and it is uncomfortable enough that most teams avoid it until an investor asks it for them.

If the model provider shipped your headline feature natively on Monday, what would you still have?

Not what would you do. What would you still have. The answer is usually one of five things, and only four of them are a company.

The fifth answer, the one that is not a company, is: a better interface. Interfaces are real work and they are genuinely valuable, but they are also the layer that gets absorbed first, because the party whose feature you are wrapping has every incentive to wrap it themselves and a much lower cost of doing so.

It is worth saying plainly that wrapper is not an insult. Every application in history is a wrapper around something: a database, an operating system, a payment network. The question was never whether you wrap. It is whether the wrapping is the part that carries the value.

The four places value actually sits

Workflow depth. The product does not answer a question. It completes a job that has steps, state, handoffs and an approval somewhere in the middle. A model answers. A workflow remembers what happened last Tuesday, knows who has to sign off, and behaves correctly when somebody is on holiday. That accumulated correctness is not something a raw capability replaces, because the capability was never the hard part.

The test is simple. Can a user get most of the value by pasting their problem into a general purpose assistant? If yes, you are selling convenience. Convenience is a real business and it is a thin one.

Data you accumulate by operating. Not data you licensed, which your competitor can also license. Data that exists only because your product ran: which suggestions were accepted and which were rejected, what the correction was, what the outcome turned out to be six weeks later. This is the asset that compounds, and it is the one most teams forget to capture because capturing it is not on the critical path to the demo.

Decide on day one what you log. It is nearly free to record and impossible to backfill.

Integration surface. Work happens where work already lives. A product that reaches into the systems of record, reads the real state, and writes back is doing something a general capability cannot do without the same integration work. That work is unglamorous, slow, and it is a moat precisely because it is unglamorous and slow.

Accountability. This is the least discussed and it may be the strongest. Model providers are explicit that output correctness is not guaranteed. Somebody has to stand behind the result. When you sell into a function that has consequences, whether financial, clinical, legal or operational, a large part of what the customer is buying is that a company exists which will answer for the output being wrong.

That has a cost. It means evaluation, monitoring, human review paths and insurance. It is also the reason a serious buyer will pay you rather than use a general tool that is free to them, and it is not a position an interface can occupy.

Write down what you are not

The most useful half of a product definition is the exclusions.

A definition that only says what you do will be stretched by every customer conversation, because saying yes is pleasant and saying no is not. Six months later you have four half-products, a roadmap nobody believes, and an engineering team that has stopped asking what the priority is because the answer keeps changing.

The working test for a product definition is this: can somebody on your team decline a customer request without asking you? If they have to ask, the definition is a description rather than a decision, and you are the bottleneck on every conversation the company has.

Write both columns. What this does. What this does not do, and where those requests go instead. Put a date on it and revisit it deliberately rather than continuously.

Three ways this goes wrong

You build the demo that impresses other builders. There is a specific kind of demo that gets applause from engineers and produces no purchase orders. It shows capability rather than completion: look what it can do, rather than look what it finished. Buyers do not buy capability. They buy the absence of a problem they currently have, and the demo that sells is often visually dull because it ends with a task being finished and a person going home.

You define the product as a capability rather than a job. Any sentence of the form we use artificial intelligence to improve something is not a product definition. It contains no user, no current alternative, and no way to tell whether it worked. Rewrite it as: this person spends this long doing this thing, it goes wrong in this way, and afterward they do not have to.

You confuse novelty with demand. That nobody else does this is not evidence that anybody wants it. Sometimes it is evidence that several people tried and discovered why not. When you find genuinely empty space, spend a day asking who else has stood here before assuming you are the first to arrive.

The eleven versions were not wasted, although at the time it felt like avoidance. Each rewrite removed something we had been carrying because it was impressive rather than because it was true. What was left was smaller than what we started with and considerably harder to argue with.

A feature is not a company. A workflow somebody is afraid to change is.

Tomorrow: the ten-name customer list, and why a market is not a segment.

Our first cap table was a spreadsheet with nine rows. Founders, a placeholder for an option pool nobody had modeled, and a note at the bottom in a different color reminding us to add the advisor we had promised something to but had not yet quantified.

It fitted on one screen. That was the last time it did.

A cap table looks like a record of who owns what. It is not. It is a forecast of who will own what once everything you have already promised comes true, and the gap between those two readings is where founders lose companies they still technically control.

Outstanding versus fully diluted

There are two numbers for every line and they are rarely the same. Outstanding shares are what has actually been issued. Fully diluted includes everything that could become a share: the unissued option pool, outstanding options, warrants, and every convertible instrument you have signed.

Founders quote outstanding. Investors read fully diluted. The number that matters in every negotiation you will ever have is the second one, so start using it now, and build the model yourself rather than accepting somebody else’s summary. Not because anyone is dishonest, but because the person who built the model understands the assumptions inside it, and in a negotiation that understanding is the entire advantage.

The option pool and where it comes from

You need equity to hire. A pool of ten to twenty percent is standard, sized against the hiring plan for the next eighteen months rather than against a number somebody quoted.

The part that surprises people is when the pool gets created. Investors almost always require it to be established before their money goes in, which means it comes out of the pre-money valuation. In practice that means the founders pay for it entirely, and the arithmetic is not intuitive.

Take a round of three million dollars on a fifteen million pre-money valuation. Post-money is eighteen million, so the new investors hold one sixth of the company, about 16.7 percent. Now add a fifteen percent option pool created pre-money. That fifteen percent is fifteen percent of the post-money company, and it is carved entirely out of the existing holders. The founders do not end up with 83.3 percent minus a bit. They end up with roughly 68.3 percent, and the fifteen points went somewhere they had not modeled.

This is not a trick and it is not hidden. It is standard practice and it is negotiable at the margin. What is not acceptable is being surprised by it on the day the term sheet arrives, because a founder who is doing this arithmetic for the first time in a meeting has already lost the argument about pool size.

SAFEs, and the trap in the word post-money

Most early money now arrives as a simple agreement that converts into equity later, usually at a valuation cap. It is fast, cheap and lawyer-light, which is why it won. It also defers the moment anybody has to think, which is why it hurts.

The critical detail is whether the cap is pre-money or post-money. Under the post-money version, which is now the common one, the investor is promised a fixed percentage of the company as it stands at conversion. That percentage does not dilute when you issue the next instrument. Only the founders dilute.

Work it through. You raise one million dollars on a ten million post-money cap. That investor is promised ten percent. Six months later you raise another million on a twelve million post-money cap. That investor is promised 8.33 percent. The first investor still gets their ten percent. The founders now hold 18.33 percent less than they did, before any priced round, before any option pool, and before anyone has valued the company in a negotiation.

Three or four of these stacked up is common, and the result is a founding team that discovers at their first priced round that they collectively hold less than half of their own company and have no idea when it happened. The instrument did not do anything unfair. Nobody modeled the conversion.

So model the conversion. Before you sign each one, build the row where all outstanding instruments convert at a plausible next round, add the pool, and look at what the founders hold. If that number makes you uncomfortable, the time to act is before signing, not after.

The small grants that add up

The large numbers get scrutiny. The small ones get waved through, and collectively they do more damage because nobody is tracking the total.

• Advisors. The market range is roughly a quarter of a percent to one percent, vesting over one or two years, with a defined commitment such as a monthly call. Anyone requesting five percent for advice is not an advisor. Vesting matters here more than anywhere else, because advisor engagement reliably decays.
• Agencies and contractors taking equity instead of cash. This is attractive when cash is short and it is almost always expensive. You are selling the most valuable asset you have at the lowest price it will ever carry, to a party whose involvement ends when the project does.
• Uncapped notes from friends and family. Well intentioned, and they convert at whatever the next round decides, which means the person who took the earliest risk gets the worst terms. That produces a conversation you will not enjoy.
• Verbal promises. A percentage mentioned in a conversation and never documented is not on the cap table, but it is absolutely in somebody’s head. Those surface during diligence, always at the worst moment.

Three ways this goes wrong

You keep the cap table in a spreadsheet past the point where that works. It works for about a year. It stops working the first time somebody exercises an option, or a note converts, or a founder departs mid-vest. Move it to a proper register before it breaks, not after, because reconstructing a cap table from email is a genuinely awful week.

You optimize for a headline valuation instead of a clean structure. A high cap feels like a win and costs nothing today. The bill arrives when the priced round has to reconcile every instrument you signed. Investors are not primarily buying your valuation history. They are buying whether the founders still own enough to stay motivated for another four years, which is the actual question behind every diligence request about the cap table.

You treat dilution as loss. It is not. Owning a smaller share of a company that exists beats owning all of one that does not. The failure is not dilution, it is unmodeled dilution, which is the same mistake as unmodeled cost and produces the same expression on the same face eighteen months later.

Every early act of generosity gets priced by the next investor, and they price it against you.

Tomorrow: the one-page product definition, and the question that decides whether you have a company or a feature.

The founder agreement was the fourth or fifth document we produced and the first one anybody was reluctant to open. It is a strange thing to write. You sit in a room with people you chose, whose judgment you trust enough to bet several years of your life on, and you write down what happens when one of you leaves and the rest of you resent it.

Nobody enjoys the conversation. Everybody who has skipped it has regretted it.

The agreement is not a legal formality wrapped around a friendship. It is the first thing the company builds, and like anything you build, it is either designed for the conditions it will actually meet or it is decorative.

Vesting is a promise to your future self

The standard shape is four years with a one year cliff, then monthly. Nothing vests for the first twelve months. At month twelve a quarter of the grant vests at once. After that it drips.

Founders resist applying this to themselves. The reasoning is always some version of: we are the ones building it, why would we restrict our own stock. The answer is that vesting is not protection against you. It is protection against the version of this company that exists after somebody leaves.

Run the scenario. Five people split the company evenly. In month seven one of them takes a job somewhere else, for reasons that are entirely understandable and possibly medical. Without vesting they walk away owning a fifth of the company, permanently, with no further obligation to anyone. The four people who remain now work for four more years knowing that twenty percent of everything they build accrues to somebody who left before the product existed. That is not a legal problem. It is a motivation problem, and it will not resolve.

With vesting, the same person leaves in month seven having crossed no cliff and keeps nothing. That sounds harsh in the abstract and it is exactly right in practice, because the alternative punishes the four people who stayed.

Two refinements worth understanding. Acceleration on a change of control determines what happens to unvested stock if the company is acquired. Single trigger accelerates on the acquisition itself, which acquirers dislike because it means the people they are buying can leave immediately. Double trigger accelerates only if the acquisition happens and the person is terminated, which is the market standard and the one you should default to. The other refinement is credit for time already served. If you have been working on this for a year before incorporating, it is normal to vest a portion at signing rather than pretend the year did not happen.

The election with a thirty day window

If your stock is subject to vesting, there is a tax election you must file within thirty days of the grant. Thirty calendar days. There are no extensions and there is no relief for not having known about it.

The mechanics matter, so here they are plainly. Restricted stock is normally taxed as it vests, at the value on each vesting date. In a company that is going well, that value rises. So you would recognize ordinary income every month, on stock you cannot sell, in a company with no liquid market, and you would owe real tax in cash on paper gains. Founders have been genuinely ruined by this.

The election lets you choose to be taxed at grant instead, when the stock is worth close to nothing. You pay tax on approximately zero, and everything afterward is capital gain rather than ordinary income. It also starts the clock for the qualified small business stock holding period discussed in Lesson 1, which is a second reason it belongs on day one rather than day thirty-one.

The cost of filing it when you did not need to is a stamp. The cost of not filing it when you did need to is uncapped. Treat it as unconditional.

The intellectual property, including the part from before the company existed

Here is the uncomfortable default: work belongs to the person who did it unless there is a written assignment. Not to the company they were thinking about forming. Not to the group chat where the idea was discussed. To the individual.

That means the prototype somebody built in the two months before incorporation, the model evaluation harness, the brand name, the domain, the pitch deck and the schema all sit outside the company until they are formally assigned into it. Investors check this. Acquirers check this harder. A single unassigned component discovered during diligence can hold up a transaction for weeks while lawyers chase a person who has since stopped answering email.

Two related traps. The first is employment agreements at day jobs, many of which claim inventions made during the employment period, sometimes regardless of whether company equipment was used. If any founder built anything material while still employed elsewhere, that needs a real answer, ideally a written release, before it becomes somebody else’s leverage. The second is the helpful friend. Somebody who contributed a weekend of work, was thanked warmly, was never paid and never signed anything, now holds a copyright interest in part of your product. Get a short assignment signed at the time. It is a one page document and it costs a favor.

The parts everyone skips

The equity terms get attention because they are about money. The following clauses get skipped because they are about behavior, and they are the ones that actually determine whether the company survives its second year.

• Roles and decision rights. Not job titles. A written statement of what each person can decide alone, what needs agreement, and what needs everyone. Without it, every disagreement escalates to a vote, and a company that votes on things moves at the speed of its slowest conversation.
• What full time means, and when it starts. Founders frequently have different runway, different obligations and different tolerance for risk. Some are in on day one, others in four months. Write down which, and tie the equity to it, because the unspoken version of this is the most common source of resentment I have seen.
• Departure mechanics. What happens to unvested stock, to vested stock, to the title, to the email address, to the customer relationships that person owned. Decide it now, when nobody is angry.
• Deadlock. An even number of founders needs a tiebreak rule. An odd number needs one too, once somebody leaves.

Three ways this goes wrong

You split evenly because it is the polite thing to do. An even split among a large founding team is often the right answer, and it is just as often the answer nobody wanted to argue about. If contributions and commitments differ materially, an even split encodes a disagreement rather than resolving it. Have the conversation while it is still cheap.

You agree it verbally and mean it sincerely. Verbal agreements between friends are perfectly genuine and completely unenforceable. They also drift, because two people remember the same conversation differently after eighteen difficult months. The document is not there because you distrust each other. It is there so that the version of you in month twenty does not have to reconstruct the version of you in month one from memory.

You defer it until the first raise. By then it is not a negotiation among peers, it is a condition imposed by a term sheet in a week when you have no leverage and no time. Every founder who has done it this way describes the same feeling.

Equity is easy to give and impossible to take back.

Tomorrow: the cap table, and what your early generosity looks like to the person writing the next check.