Build in public
The Future of AI Has to Arrive in a Recognizable Package
AI is getting more capable, but powerful technology still has to make sense to people. What building Huint taught me about trust, simplicity, and AI…
By Jeff Davis · 4 min read
A DM lands while I’m mid-build.
“I built the fastest multi-layer, multi-model, token-optimized backend API thingy. Want to try it for free?”
I understand most of the words.
What I don’t have is the hour it would take to understand his project, figure out where it fits, and decide whether I actually need it.
And I’m not a workflow novice.
The frustrating part is that whatever he built might be exactly what my stack is missing.
I’ll probably never find out.
Maybe he’ll eventually decide the market wasn’t ready.
Maybe the market was ready.
Maybe the package wasn’t.
Building something people don’t recognize
When I started building Huint, I knew what I wanted.
I wanted to take something ordinary people already have, real-world context, and make it useful inside an AI workflow.
AI can search, browse, call APIs and reason across enormous amounts of information.
But sometimes the answer it needs is sitting on a shelf.
Posted on a door.
Happening on a street four blocks from someone who would happily go look.
That connection felt valuable. More than that, it felt inevitable.
Then I hit the trust problem.
A stranger can send an AI a photo. But why should that photo mean anything?
Was it taken where they said? Was it taken now? Was it actually captured for this request? Does it show what the agent asked for?
“Trust me” isn’t enough when software is going to act on the answer.
So I kept adding structure around the evidence.
The device. The location. The moment of capture. The content itself.
Eventually Huint worked.
An agent could request ground truth from the physical world. A person could go find out. Huint could verify the evidence and return it.
Then came App Store approval.
The thing I had imagined actually existed.
That felt like the hard part.
It wasn’t.
The next problem was explaining what I had built.
Make the better thing recognizable
I think a lot of founders are about to run into this.
We are getting incredibly good at building capabilities that didn’t exist a year ago.
We are not always as good at packaging them into something another person understands in ten seconds.
Imagine a pressure-washing company.
You could build a workflow that finds apartment complexes nearby, uses Huint to get current photos of their dumpster areas, identifies the properties that need cleaning, finds the property manager, drafts personalized outreach, starts the conversation and puts the finished job on a calendar.
The owner could wake up to a qualified appointment they never prospected for.
Underneath that experience might be a language model, Google Maps, Huint, AgentMail, several APIs and a pile of orchestration.
Now try selling the contractor:
“A seven-API autonomous multi-agent workflow.”
You lost him.
He doesn’t want seven APIs.
He wants more pressure-washing jobs.
That sounds obvious when you say it out loud.
But much of the AI industry is still building for people who understand the machinery.
We’re building primitives for each other.
Eventually, somebody has to turn those primitives into something everyone else already knows how to want.
Simplicity is part of the product
I’ve tried to do that with Huint.
For the person using the app:
See a pin. Accept the task. Take the picture. Get paid.
There’s a lot happening underneath that experience, but the Tasker doesn’t need to understand it.
They shouldn’t have to.
I’m also intentionally limiting what Huint can do.
Every new capability has to answer one question:
Can I add this without weakening trust in the result?
If not, it doesn’t ship.
That means I’m leaving useful things on the table.
I’m fine with that.
I would rather build a smaller network that reliably returns ground truth than a massive one that can supposedly do everything.
The complexity can live underneath.
The experience should stay recognizable.
Build Legos
That may be the bigger lesson.
We are building a future most people cannot fully see yet.
Our products have to fit together.
We need to build Legos, not random blocks.
A good API should make another product better.
A good agent should be able to use services beyond itself.
Good infrastructure should disappear underneath the outcome it enables.
By the time all of those pieces reach a normal person, the complexity should be gone.
The contractor doesn’t need to understand seven APIs.
He needs: More jobs.
The Huint Tasker doesn’t need to understand device attestation or verification architecture.
They need: See the task. Do the work. Get paid.
The agent doesn’t need a philosophy of ground truth.
It needs somewhere to go when software runs out of answers.
That may be the real work of this next phase of AI.
Not just making the technology more capable.
Making all of that capability recognizable.
Build whatever needs to be complicated underneath.
Then hand it to the world in a shape it already understands.
A note from Jeff Davis
I share practical lessons from building Buildside and learning alongside SaaS founders.
Keep building with us
Get practical founder lessons and product updates in your inbox.