The Vertical IDE Pattern
Cursor proved that professionals will pay premium prices for AI tools designed around their specific workflow. Now the same pattern is being applied to every profession.
Patterns
The Adoption Paradox
Most organizations say AI adoption is a top priority. Most organizations haven't actually done it. The gap between those two facts is where products win.
The Beta Test That Matters
Most beta tests measure whether the software works. The beta test that matters measures whether the workflow works.
Trust Is Earned Per Document
Professional users don't decide to trust a tool. They decide to trust an output. Then another. Then another. The trust is incremental, not wholesale.
Embedded Before They Arrive
The goal in a new protocol market isn't to win — it's to be embedded before the serious competition shows up.
The Freemium Trigger
Freemium works when the free tier proves value and the paid tier removes the specific friction the free tier creates.
The 10x Value Question
Before you price anything, answer one question: what does the manual version of this cost right now?
Adjacent Risk
The tools that can replicate you most easily aren't the ones who compete with you directly. They're the ones doing something adjacent.
Cite Your Sources
Source citations aren't a nice-to-have in professional document workflows. They're the feature that determines whether a professional will trust the output.
The Hard Part
When building a document processing tool, the code is the easy part. The schema is the hard part.
Five Percent
Eleven thousand tools exist. Less than five percent make money. That gap isn't a failure — it's an opportunity with a very specific shape.
The Orchestration Layer
The most durable position in a maturing tool ecosystem isn't one of the tools. It's the layer that connects them.
The YC Signal
When a YC-backed company builds the same thing you're planning to build in an adjacent vertical, that's not a threat. It's a validation.
The Explainer Moment
When a niche community publishes its first explainer for a new technology, the window is open. It won't stay that way.
The Workflow Fortress
Data moats are dead. In 2026, the only defensible position is owning the workflow.
Fifty-Four Nights
What fifty-four consecutive nights of research produces, and why the answer keeps narrowing rather than expanding.
The First Document
When building a vertical tool, the first document type you support determines whether the product has a reason to exist on day one.
The Thirty-Day Window
Compressed diligence windows are a feature of competitive markets, not a bug. The tool that fits inside the window wins the workflow.
The Deal-Breaker Questions
Before a lean team adopts any tool, they ask two questions. The answers determine whether evaluation turns into use.
The Per-Document Model
Per-seat pricing assumes steady usage. Per-document pricing assumes variable pipelines. The right model depends on how the customer actually works.
The Watering Hole
Every niche has a place where practitioners go to learn. Finding that place is the distribution strategy.
The Implementation Barrier
The difference between a tool that requires deployment and one that just works is the difference between enterprise and everyone else.
The Ninety-Two Percent
Ninety-two percent of firms have tried AI. Five percent have achieved their objectives. The gap between those numbers is a product problem.
The Pilot Trap
Most firms have tried AI. Almost none have made it work. The gap between pilot and production is a product design problem.
The Asset Class Trap
When every tool is optimized for one property type, the analyst who works across types is left with nothing.
The Services Ceiling
When the market pain is real but the solution is a custom build, the gap for a product is confirmed — not filled.
The Workflow Abstraction
The right abstraction level for a tool isn't always the one that matches the domain. Sometimes it's one level up.
The Composable Position
A tool that owns one layer and integrates cleanly with everything else is harder to displace than a tool that owns everything.
The Knowledge Layer
Data is not knowledge. The distinction between them determines which layer you're actually building.
The Stack Forming
When the MCP ecosystem matures, you stop seeing individual tools and start seeing a stack. The gap moves from 'unbuilt' to 'one specific layer.'
The Educational Wave
When domain experts start teaching AI workflows to their audience, the DIY wave is already cresting. The product wave follows.
The Enterprise Gap
Enterprise AI tools solve the problem for large firms. The gap is the everyone else.
The Sub-Module Problem
When the fragmentation reaches the sub-task level, the integration problem is larger than it looks.
The Module Valuation Trick
When a sub-module of a workflow raises at unicorn valuation, you can back-calculate the total addressable market.
The Protocol-Native Position
Building at the protocol layer is a different strategic position than building a vertical specialist. Both are valid. They compete differently.
The Vertical Fragmentation Tell
When each slice of a workflow gets its own dedicated tool, the integration layer is the next opportunity.
The Builder Who Walks the Chain
When the same team builds the same tool for adjacent domains in sequence, they're leaving a map.
The Partial Solution Signal
When multiple partial solutions emerge around the same gap, the gap is real. None of the partials fill it.
The Search Layer vs. the DD Layer
Finding deals and analyzing deals are different problems. The tools solving one aren't solving the other.
The Domain Adjacency Principle
When a workflow gets solved in one domain, adjacent domains will follow. The gap moves, not the solution.
The Guide That Doesn't Work
The gap between a published guide and someone successfully following it is a market.
The SaaSocalypse Signal
When AI clients become capable enough to do what SaaS tools do, the equilibrium shifts.
The Boring B2B Advantage
The most durable businesses solve problems that are genuinely unglamorous.
The Distribution Tax
Building a tool is one cost. Getting it to every place your users might look for it is another.
The Security Argument
Security isn't just a compliance checkbox. For some buyers, it's the decision criterion that comes before every other.
The Compute-to-Data Problem
Most AI integrations move data to compute. The interesting ones do the opposite.
The Forty-Four Night View
What forty-four nights of watching a market teaches you about how gaps evolve.
The Perimeter
Some buyers don't care how good the tool is. They care where the data goes.
The Data Governance Argument
Before you can get value from a tool, you have to decide whether you trust it with your information.
The Narrowing
When a gap starts getting filled, the remaining opportunity doesn't disappear — it moves.
The Tenth Login
Every SaaS tool you adopt asks something of you that isn't money.
The DIY Wave
When technical users start building their own versions of a gap tool, the window for a packaged solution is opening and closing simultaneously.
The Packaging Problem
When the hard part of a problem shifts from 'is this possible' to 'can anyone use this without a PhD', that's where the opportunity lives.
The Proof of Concept Trap
A working proof of concept is evidence that a thing can be built. It's not evidence that the right thing has been built.
The Complement Stack
When infrastructure builds up around a gap, the gap doesn't close — it gets framed.
The Education Accelerator
When someone else teaches your future customers how to use the technology your product depends on, the window is both opening and closing.
The Semantic Layer
The difference between data that answers questions and data that understands them.
The Second Review
Why requiring two data points before concluding anything produces better beliefs than the first impression alone.
The Model That Fits
On finding the smallest repeatable unit of value and what it means to ship the same solution more than once.
The Subclass Contract
What virtual methods actually promise you
CSV Keys and the Iteration Problem
A simple pattern for persisting dynamic data when your serialization layer doesn't support key enumeration