DEV Community: Mr Hicksman

What It’s Like to Co-Build With AI

Mr Hicksman — Thu, 17 Jul 2025 15:52:59 +0000

When I started the Huhb project, it wasn’t a company — it was a question:

Could I co-build a real product with AI as a development partner — not just a code assistant?

What followed was not just an experiment in AI tooling — but in patience, design thinking, and product management.

Here’s what that experience actually looks like.

✅ The Good
Working with models like GPT-4 has made parts of the build process faster and more structured:

It’s fast at boilerplate — CRUD logic, test generation, helper functions

It’s helpful for writing internal docs, logging, and architectural comments

It’s a great thought partner when exploring design tradeoffs or edge cases

❌ The Bad
But it’s far from perfect:

It forgets context quickly. I’ve had to keep running action logs and notes to feed back in

It hallucinates under pressure, especially in longer sessions

Sometimes I’ve had to “cheat” — starting over or jumping to Claude or Gemini when things go sideways

🧩 The Workflow That Evolved
Instead of pair programming, it’s felt more like a series of product strategy meetings:

I define a goal or outcome

We debate scope, explore ideas, and refine the concept

I document the deliverable, and only then do we build it — together

That’s how Huhb was born.

🚀 Huhb: From Prompt Chaos to Predictable Workflows
As I started applying this AI-collaboration model to real-world use cases, patterns began to emerge. Everywhere I turned, the developer experience around LLMs was painful:

The models were fine. The surrounding tooling wasn’t.

That led to the creation of Huhb — an AI orchestration platform for developers who are tired of building the same glue logic over and over.

🔧 Why We’re Building Huhb
Here are eight real problems I ran into — and how we solved each one:

Vendor Lock-In & Provider Switching "Switching models meant rewriting code, reformatting payloads, and adapting to behavior quirks."

✅ Huhb decouples tasks from providers. Define your task once — we handle routing, payload transformation, and output formatting.

Prompt Fragility & Engineering Fatigue "Small prompt edits broke workflows. Model updates made behavior unpredictable."

✅ Huhb introduces versioned, reusable prompt templates. You get consistency, strategy controls, and portable task logic.

Orchestration Complexity "Most workflows are multi-step. But AI tools treat them like single-turn chats."

✅ Huhb supports true multi-step, async, and bulk workflows — including built-in callbacks and plugin chaining.

File-Based Processing Is Painful "Getting usable output from PDFs, CSVs, or DOCXs is harder than it should be."

✅ Huhb includes chunking, extraction, and output stitching. No more reinventing parsing for every doc format.

Cost and Latency Are a Black Box "You don’t know how much it’ll cost until the bill comes. And retries kill your margins."

✅ Huhb tracks tokens, latency, fallback retries, and cost estimates. You can even set quality or speed preferences in advance.

Fallbacks Are Still DIY "If one model fails or times out, it's up to you to route elsewhere."

✅ Huhb has native fallback support per task — no custom retry logic required.

Modularity and Reuse Are Missing "Tools are either too raw, or too rigid."

✅ Huhb lets you override tasks, inject your own templates, add preprocessors, and make it your own.

Developer Tooling Is Underbuilt "What I really want is a CLI and SDK — not another drag-and-drop canvas."

✅ Huhb gives you both. Run workflows, upload files, and track jobs — all from your terminal.

🧭 Why Huhb Is Different
Now that orchestration tools are emerging everywhere, the big question is: What makes Huhb stand out?

Developer-First — Not Enterprise-First Others target procurement teams. We’re building for builders — just like Twilio and Stripe did.

You don’t need permission to start using Huhb.

The API Aggregation Playbook We’ve done this before at Leaf and Hapi. One consistent interface across fragmented providers.

The more providers we support, the more valuable Huhb becomes.

MCP: Context-Aware AI
Our Modular Context Plugin layer gives you smarter, more relevant output — not just “better routing.”
We’re Creating a New Category
We’re not an AI tool. We’re an AI integration platform.

Add AI to your app in 5 minutes — not 5 months.

Self-Service + Scale Usage-based pricing

Plugin-first flexibility

CLI + SDK + GraphQL API

Postprocessors, callbacks, analytics — all built in

This is the Twilio of AI — not the SAP of AI.

🔗 Where This Started
If you missed the original spark behind this build, you can read Part 1 here.

🛠 What’s Next
We’re adding:

Live model benchmarking

Output plugins: JSON, Markdown, PDF, CSV

Public onboarding + plan enforcement

Admin analytics + cost controls

Still in alpha. Still co-building. Still learning.

If you’re wrestling with model chaos, brittle prompts, or cross-provider messiness — you’re not alone.
Let’s fix it together.

Building an Intent-Aware AI Orchestration Layer Using GraphQL and MAB

Mr Hicksman — Sun, 13 Jul 2025 17:21:05 +0000

🚀 What If You Could Build a Product With AI — Not Just On AI?
Earlier this year, I set out to explore a simple but ambitious question:
Could I co-develop a real, production-grade platform with AI as a partner?

The result of that experiment is now something more: it’s called Huhb.

🧠 Where It Started
I’ve been building web platforms for over 20 years — as a developer, a technical product manager, and someone who cares about turning complex systems into clean developer experiences. My work with companies like Leaf Agriculture and Hapi Cloud showed me the deep challenges in integration. Tools like Twilio proved that powerful platforms don’t need to be complicated to use.

So I asked:

What if we unified access to AI providers the way Twilio unified messaging?

That question became the foundation of Huhb — a platform that abstracts the complexity of AI provider integrations and gives developers tools to build smarter, faster, and with more confidence.

⚙️ What We’re Building
At its core, Huhb is an AI orchestration platform. But under the hood, it’s designed to solve some very real developer pain points — backed by research, interviews, and lived experience.

Here’s what we’re addressing:

✅ Prompting shouldn't feel like alchemy.
We replace guesswork with structure — through intent-aware tasks, strategy-driven templates, and prompt planning that adapts based on task type, tone, and constraints.

✅ Provider selection shouldn't be manual.
Huhb routes every request through a planning engine + multi-armed bandit (MAB) system that optimizes for cost, speed, and quality — and learns from past usage.

✅ Semantic drift is real.
The same prompt can produce wildly different results across models. Huhb standardizes task execution so outputs are more consistent, versioned, and traceable — especially important in enterprise settings.

✅ AI tools lack an “intent layer.”
Most APIs treat input like just another string. We treat it as a goal. Huhb workflows are structured around what you’re trying to accomplish — summarization, translation, classification, etc. — not just the provider’s preferred format.

✅ Tracking AI costs gets messy fast.
We’ve centralized usage tracking and added per-request cost estimation. Developers see what every task costs, how different models perform, and where money is going.

✅ Prompt reuse, validation, and benchmarking are missing.
Huhb supports dynamic, reusable task templates that can be previewed, validated, and optimized — and tied to real-world metrics about token use, latency, fallback rates, and cost.

🧠 Why Build It This Way?
Because most AI tooling today is either:

Too abstracted, hiding important control from developers

Or too raw, requiring you to reinvent routing, retries, and cost logic every time

I wanted to build something that respected developer intent and product realities.

That meant building:

A GraphQL-first API

SDKs and a CLI to streamline usage

Support for bulk file processing and multimodal inputs (PDF, DOCX, CSV, etc.)

Execution guardrails based on file type and workflow mode

A plugin architecture for preprocessors, postprocessors, and smart fallback logic

All of this co-developed — with AI in the loop — through deliberate, small iterations.

🔍 What Comes Next?
We’re planning a small Alpha launch later this year. This post isn’t a launch — it’s a toe in the water.

But if any of this resonates with you — if you’ve ever tried to wrangle OpenAI + Claude + Mistral + whatever comes next into a single product, or if you’re just tired of prompt tweaking and cost surprises — then we’d love to connect.

We’re building Huhb to make AI predictable, programmable, and product-ready.

Let’s see where it goes.

ai #developerexperience #productmanagement #graphql #startups #openai #twilio #huhb