Todd AlbertThere's a pattern I've watched play out at company after company.
A team ships a new and shiny AI feature, usually a chat box bolted onto the corner of an existing product. There's a launch announcement. A demo that gets applause. Maybe a press release with the word transform in it. And then, three weeks later, someone pulls the usage numbers and the room goes quiet.
The feature works. It's just that almost nobody uses it.
This isn't a model problem, and it isn't a marketing problem. It's a positioning problem, and most teams don't realize they've lost the fight before they've written a line of code.
You picked a fight you can't win
Here's the uncomfortable part: if your AI feature's pitch is "a smart assistant that can answer questions," you've entered a race against companies spending tens of billions of dollars to build exactly that. OpenAI, Google, and Anthropic will out-resource you on the general-purpose model. And your user already has one of them open in another tab.
You cannot out-LLM ChatGPT or Gemini. Stop trying. The interesting question isn't how to compete with the frontier labs. It's where they can't compete with you.
Before we get there, two traps worth naming, because nearly every dead-on-arrival AI feature falls into one of them.
The trap of mimicry. You clone the generic assistant. It's easy to copy, so it's competitively weak. It doesn't solve a problem anyone was actually losing sleep over. Worse, it adds cognitive load (now there's one more box to think about), and it knows nothing about your user's real data, their workflows, their constraints, or what "success" even means for them. It's a stranger offering advice about a job it's never seen.
The trust deficit. The first question a serious customer asks is "Are you training on my data?" The second is whether they can trust the output without checking it themselves. And if they have to fact-check every answer, you haven't saved them work; you've added a review step. Trust isn't a default setting. It's earned slowly, and lost instantly.
What you own that the labs never will
The foundation labs have the best models. You have something they don't and can't buy: proximity to your customers.
You sit on your customers' actual data: their support tickets, transaction history, emails, documents, the CRM, the ERP, the logs. You operate inside the exact workflows they live in all day. You know when they're trying to make a decision. The frontier labs are building a brilliant general mind. You're building the only system that knows this customer's world in detail.
That proximity is the moat. How you fortify it into a defensible feature comes down to four disciplines.
Ground it: context. A generic model is impressive in a vacuum and useless in a meeting. Ground it in the customer's own data and have it fire inside the context where they already work, ideally on event-driven triggers, so it shows up at the moment of need instead of waiting to be summoned. Picture a support agent opening a ticket. A generic assistant greets them with a blank prompt and a blinking cursor. A grounded one has already read this customer's last three tickets, knows they're on the enterprise plan, has matched their complaint to a known bug, and drafted a reply with the right help doc linked, before the customer has typed a word. Relevance beats raw intelligence almost every time.
Let it act: actionability. An answer is a suggestion. An action is a result. The features people come to depend on don't just tell you what to do. They reach into the APIs and databases, update the ticket, complete the multi-step task, and tie the work to a real entity like an order or an account. When that same agent decides to issue a refund, the difference is stark. A chatbot hands them a tidy paragraph explaining the refund policy. A real AI feature issues the refund, updates the order status, logs the reason code, and queues the customer notification, collapsing eight clicks across three systems into a single approval. The gap between "here's what I'd do" and "done, here's what I did" is the gap between a frustrated and a delighted customer.
Get out of the way: integration. This is a UX discipline more than an AI one. The best assistance is inline, contextual, and anticipatory. One click. Steps removed, not added. Aim for micro-moments, not monolithic features: suggest the next steps, not the entire multi-step workflow. And teach a repeatable pattern users can trust: generate a draft, review it against a checklist, apply in one click. Here's the pattern from my own work. Instead of making an instructor open an AI agent and figure out what to ask it, the system looks at the course they've just built and proactively offers a few concrete improvements (add a quiz here, layer in gamification, fill a gap with a missing module), each one a single click to apply. The user never wrote a prompt. They just saw a better version of their own work and accepted it. Unobtrusive software breeds delighted and happy customers.
Earn the trust, then keep it. This is what separates a neat demo from something people run their day on. Give users real controls, not one on/off switch but granular, tunable guardrails: what the AI is allowed to touch, which sources it may draw from, the tone it takes, and exactly where it has to stop and ask a human. Treat auditing and data privacy as first-class features, on par with capability: per-tenant isolation, an explicit policy on whether you train on customer data, and a human in the loop for anything high-risk. Cite your sources and let the user verify them in a click. Better still, verify the work before they ever see it: a second model checks the first's output and catches the confident-but-wrong answer before it reaches the screen.
A compliance-bound buyer will not touch a feature that might bleed their data into another customer's tenant. But that same buyer will lean hard on one that answers strictly from their uploaded documents, shows its sources so every claim is one click from verification, and routes anything irreversible through a human first. One of those gets banned by procurement. The other gets rolled out company-wide. Capability earns the first try; control earns the customer's trust and their business long-term.
The two-minute rule
Now the execution, which is where good intentions usually die.
Don't go hunting for the feature that will change everything. Go hunting for the boring stuff: the stressful, repetitive, slow, error-prone steps where ten minutes of drudgery can collapse into ten seconds. Then prioritize ruthlessly by a simple formula:
Reach × Frequency × Friction. How many users does it touch, how often does it happen, and how painful is it each time? The features that score high on all three are the ones worth building. Find the smallest version that still feels a little magical, and ship that first.
Here's the principle that should be taped to your monitor:
AI that saves your customers two minutes will be used more than AI that promises to change their entire workflow.
The two-minute win gets opened every day. The workflow-changer gets opened once, screenshotted for the launch post, and quietly abandoned. Adoption compounds; ambition doesn't.
So design for adoption directly. Lean on inline assist (autocomplete, one-click actions, smart defaults) for the high-frequency moments. Use autonomous agents with guardrails where the task is well-defined and the stakes are bounded. Position the AI as a co-pilot for genuinely complex decisions, where the human stays in charge. And wherever you can, explain and act: don't hand the user a bare answer, hand them an explanation plus a proposed action they can accept or reject.
Don't sell it. Bundle it.
A final, counterintuitive point on go-to-market: resist the urge to launch your AI as a standalone product with its own price tag. Bundle it into the plans customers already pay for. It raises the perceived value of the whole product instead of asking people to make a fresh purchasing decision about a feature they haven't learned to need yet.
Build the narrative around time saved, not just intelligence gained. Lead with one or two flagship demos that show the magical moment cleanly. And aim, above all, to ship the single use case your customers genuinely can't live without, because one indispensable feature does more for retention than ten impressive ones.
The position worth holding
You won't lose your customers to the frontier labs.
They're building the engine, the most powerful general-purpose model money can buy. You're building the car that fits this customer's garage, knows this customer's roads, and is already warmed up and waiting when they walk out the door in the morning.
Context, actionability, integration, trust. Ruthless problem selection. Save people time. That's not the consolation prize for losing the model race. It's the whole game.
