
Stop Bolting On AI. Start Building With It.
There’s a familiar pattern in AI products:
- Take an existing app.
- Add a chatbot.
- Call it “AI-powered.”
This is the bolt-on mentality — AI as frosting on the same old cake.
The problem isn’t that the chatbot exists. It’s that nobody asked what the customer is actually trying to get done, and whether a chat box is the best way to help them do it.
The more useful design questions:
- What would this process look like if the right context was already there?
- What if the app prepared the next best action for the user to confirm?
- What if decisions didn’t require hunting for context?
Sometimes the answer is to rethink the workflow. Sometimes it’s a small assisted feature in exactly the right place. Done well, AI can collapse some complexity, take routine busywork off people, and shift more of their time from “doing” to “deciding”. None of that is automatic, and the biggest redesign isn’t always the most valuable thing to build.
Compare the options for one outcome
Illustrative example, invented. You build invoicing software. The customer outcome is getting paid on time without awkward chasing.
| Approach | What it looks like | Strengths | Risks |
|---|---|---|---|
| Assistance | A “draft reminder” button that writes a polite chaser from the invoice and the client’s history; the user edits and sends it | Cheap to build; the user keeps control of tone and relationships | Saves less time; relies on the user remembering to use it |
| Fixed automation | Scheduled reminders at set points after the due date, from templates the user approves once | Predictable, easy to explain, no model involved | Blunt: it reminds a client who has already said payment is on its way |
| Workflow redesign | The product tracks each overdue invoice to payment, reads replies, adjusts the schedule, and escalates to the user when a client disputes or goes quiet | Handles the messy middle; closer to the outcome itself | Most to build and test; it messages your customer’s own clients, so a mistake lands on their relationships |
For plenty of customers, the assisted button plus fixed reminders is the better product: cheaper, clearer, and nothing goes out without the user knowing what it says. The redesign earns its complexity only if the messy middle is where customers actually lose money and time, and only if you can bound what it may send.
Who owns what, if you build the redesign
Illustrative example, continuing the invented invoicing product. Before the redesigned version sends anything, settle who holds each responsibility:
- Granting authority: the customer’s account owner turns sending on, one message type at a time, such as a polite reminder before the due date. It starts off. Nothing about disputes, fees or terms is ever on the list.
- Checking outcomes: the account owner gets a weekly list of every invoice the product marked resolved, matched against payments in their own accounting records. Any invoice marked resolved without a matching payment is flagged for them that day rather than waiting for the weekly list.
- Handling errors: alerts about a wrong send or a suspect closure go to the account owner, who has one control that stops all further sends. The account owner reopens any invoice closed by mistake and decides what to say to the client. Your team owns finding and fixing the rule that caused it before sending is switched back on.
An illustrative failure
Illustrative example, invented. The redesigned version reads a client’s reply saying they’re disputing one line of the invoice as a promise to pay, marks the invoice resolved, and stops chasing. Nobody notices for weeks. Or it sends a firm final notice to the user’s biggest client in the middle of a renegotiation the product knew nothing about. Either way, the message can’t be unsent, and it’s your customer’s relationship that takes the hit.
Operators running agents report the same shape of failure. Writing about his team’s go-to-market agent stack, SaaStr’s Jason Lemkin recounts an agent sending an invitation that couldn’t be recalled, from a sender address its rules had prohibited for years (SaaStr, undated). His takeaway was to size review to how far a mistake could spread, not to how small the task looks. That’s one operator’s account, not a measure of how often this happens. The lesson I take from it is narrower: a written rule isn’t the same as a boundary the system can’t cross.
When not to hand it over
In the invoicing example, keep sending with the user, or stick with assistance, when:
- the client has replied with anything other than a clear payment date
- the message would threaten late fees or collections, or change terms
- the user has flagged the client as sensitive, or the invoice is large
- the product can’t tell what the user’s relationship with that client is like
- the user hasn’t explicitly turned on sending for that kind of message
Before your product can send or spend
Pick one customer outcome your product serves, and sketch the assistance, fixed-automation and redesigned versions side by side. Before you give any version authority to send messages or spend money on your users’ behalf, decide what you’ll evaluate across all three:
- whether the outcome actually happens, checked in the customer’s records rather than the product’s activity log
- how often each version gets it wrong, and what a wrong action costs the user
- whether a user can see what was sent, stop further sends, and correct a mistake
- who grants sending authority, who checks payment and closure records and how often, and who receives errors and reopens a wrong closure
- which actions the user must approve, and how the product behaves when they don’t respond
If the small assisted feature wins on those terms, ship that. Run any version that can send or spend through the autonomy test first. And if you’re deciding what to hand over in your own operations rather than in a product, I’ve covered that side in AI is not your assistant, it’s your process.
Updated:
Want help turning ideas like these into reality? Let's talk.