Composing Success: Building with AI Tools

I used to think building was about writing code. Then I built a chatbot platform that serves millions of conversations, and I learned something different: building is about choosing what not to write.

The Lego Revelation

The first time I wired together OpenAI's API with Supabase's vector store, something clicked. Not a technical revelation—the code was straightforward. What struck me was the feeling: like snapping two Lego blocks together and watching a castle emerge.

I wasn't building a database. I wasn't implementing embeddings from scratch. I was composing. Selecting. Arranging. The infrastructure already existed; I just needed to know which pieces fit.

This is what the textbooks miss about modern AI engineering. The skill isn't in the algorithms anymore. It's in the architecture of choices.

When APIs Become Infrastructure

Chatbase started simple: Supabase for data, OpenAI for intelligence, Stripe for payments. Clean. Minimal. The kind of stack you can explain in one breath.

Then scale happened. Not gradually—violently. Millions of messages. Dozens of use cases. Customers asking for Claude, for Gemini, for models we'd never heard of.

We didn't rebuild the platform. We recomposed it. Added Pinecone when Supabase's vector search hit limits. Integrated LangChain when routing between models became complex. Wove in Helicone for observability because production systems demand visibility.

Every addition felt less like coding and more like conducting—orchestrating services that already knew their parts, helping them harmonize.

The Stack That Grows Itself

Here's what my stack looks like now, and why each piece earned its place:

Foundation layer: Supabase still runs the show. PostgreSQL that scales, auth that works, real-time that just happens. Some foundations are worth keeping.

Intelligence layer: OpenAI, Anthropic, Google, Cohere. Not OR—AND. Users don't care about model religion. They care about answers. Multi-LLM became infrastructure, not features.

Vector layer: Pinecone entered when similarity search became the bottleneck. Pgvector handles metadata-heavy queries. Weaviate experiments sit in staging. Each serves its purpose.

Orchestration: LangChain for the complex flows. LlamaIndex when retrieval needs precision. Semantic Kernel for the enterprise integrations that pay the bills.

I didn't plan this architecture. I discovered it, one production crisis at a time.

What Building Teaches You

The junior engineer in me would have custom-built everything. Vector database? I could implement that. Agent framework? How hard could it be?

The production engineer knows better. Every line of custom code is a line I have to maintain when the 3 AM alert goes off. Every reinvented wheel is a wheel that needs monitoring, scaling, debugging.

But here's the paradox: choosing what to build requires deeper understanding than building everything. You need to know vector similarity cold to recognize when Pinecone's clustering beats pgvector's simplicity. You need to understand tokenization to know which LLM API to call for which task.

Composition isn't easier than creation. It's harder. It demands taste.

The Future Feels Like This

I watch new engineers enter the field, and they ask: "Should I learn embeddings from scratch? Should I build my own agent framework?"

I tell them: learn the concepts deeply, then use the tools ruthlessly. Understand how attention mechanisms work, then call the API. Study retrieval-augmented generation, then pick the framework that ships.

The companies winning in AI aren't the ones with the best algorithms. They're the ones with the best taste in recombination. The ones who see tools as Lego blocks and build castles while others are still mixing concrete.

What I've Learned

Building Chatbase taught me that modern engineering is bricolage—the art of making do with what's at hand, but making it exceptional. Every API is a capability. Every service is a building block. The skill is in knowing which blocks to stack, and when to stop stacking.

Research prototypes become production reality when you stop asking "can I build this?" and start asking "what can I compose?"

The cursor blinks in my terminal. The stack hums. Somewhere, another conversation starts, routed through services I didn't write but learned to orchestrate.

This is what building feels like now. Less like construction, more like composition. Less like coding, more like conducting.

And honestly? I wouldn't have it any other way.