Summary: With ChatGPT, Claude, Cursor, and no-code builders like Bolt and Lovable, it's never been easier to ship a multimodal AI prototype. You can vibe-code a RAG app or a video analysis pipeline in an afternoon. But shipping isn't the hard part. Maintaining is. When the prototype becomes production, you need versioning, lineage, incremental updates, caching, error handling, and retrieval that actually stays in sync. Glue code can't provide this reliably. The infrastructure layer needs to handle it for you.
The Shipping Illusion#
Something remarkable has happened in the last two years. AI coding assistants (ChatGPT, Claude, Cursor, Copilot) have made it trivially easy to write working code. Pair that with no-code platforms like Bolt, Lovable, and Replit, and anyone can ship a functioning AI application in an afternoon.
Need a RAG pipeline? Ask Claude to write one. Video analysis? Cursor will scaffold it. Document processing? A few prompts and you have a working prototype.
And it works! The demo is impressive. The investor is excited. The team starts using it internally.
Then week two happens.
What Happens in Week Two#
The prototype that ChatGPT helped you build starts showing its seams. Here's what typically goes wrong:
1. No Incremental Updates#
You add new documents to your RAG knowledge base. The vibe-coded pipeline re-embeds everything, not just the new docs. Processing time grows linearly with dataset size. What took 5 minutes with 100 documents now takes 3 hours with 10,000.
The AI assistant that wrote your code didn't know about incremental computation. It wrote a script that processes everything from scratch every time.
2. No Versioning Across the Pipeline#
You change your chunking strategy to improve retrieval quality. Results get worse. You want to roll back. But which version of your chunks was better? Which embedding model produced which results? Your Pinecone index was overwritten. Your Postgres metadata was updated in place. There's no way to compare or revert.
The AI assistant wrote code that works forward but has no concept of time travel or version history.
3. Stale Indexes and Zombie Vectors#
You delete some documents from your knowledge base. The metadata rows are gone from Postgres. But the embeddings are still in Pinecone: zombie vectors pointing to data that no longer exists. Your RAG app starts hallucinating context from deleted content.
The AI assistant wrote separate scripts for each service. It didn't implement cross-service synchronization because that's a distributed systems problem, not a coding problem.
4. No Error Recovery#
The OpenAI API rate-limits you at 3am. Your pipeline crashes halfway through processing 500 videos. 247 are done, 253 aren't. When you restart, it tries to process all 500 again, re-calling APIs for the 247 that already succeeded, wasting time and money.
The AI assistant didn't implement rate limiting, retries with backoff, or checkpointing because you didn't ask for it, and even if you had, it would have been another 200 lines of infrastructure code.
5. No Lineage or Audit Trail#
Your legal team asks: "Which version of GPT-4 generated this summary? When? From which source documents?" You can't answer. The pipeline doesn't track provenance. Outputs aren't connected to inputs.
For a prototype, nobody cares. For production, especially in healthcare, security, or finance, this is a dealbreaker.
The Gap: What Shipping Doesn't Cover#
Here's the uncomfortable truth about vibe-coded AI applications. An AI coding assistant can write:
- A script that calls OpenAI's API
- A Pinecone client that stores embeddings
- A LangChain chain that does retrieval
- An Airflow DAG that runs daily
But it can't architect a system that provides:
- Incremental computation: only process what changed
- Automatic versioning: every data and schema change tracked
- Cross-service synchronization: delete a doc, embeddings vanish too
- Error recovery and caching: resume from where you crashed
- Lineage and provenance: trace any output to its source
- Type safety: catch schema mismatches before runtime
These aren't features you can bolt on. They're architectural properties that have to be designed into the system from the ground up. That's the difference between a tool and infrastructure.
The Real Cost: Maintenance Tax#
The classic statistic in traditional software is that 80% of cost is maintenance, not initial development. For AI applications, it's even worse because:
- Data changes constantly. New documents, new videos, updated content. Each change should propagate efficiently, not trigger full reruns.
- Models change constantly. New embedding models, new LLM versions, updated prompts. You need to A/B test and roll back.
- Requirements change constantly. "Can we add audio transcription?" "Can we search by image similarity?" Each new capability shouldn't require re-architecting the pipeline.
A vibe-coded prototype optimizes for time-to-first-demo. Production optimizes for time-to-iterate. These are fundamentally different objectives, and the code that achieves one is typically hostile to the other.
What Production Actually Needs: Declarative Infrastructure#
The answer isn't "don't use AI coding assistants". They're incredibly productive for the application layer (your FastAPI routes, your React components, your business logic). The answer is to use them on top of infrastructure that handles the hard parts.
Here's what the same RAG pipeline looks like when built on declarative data infrastructure:
The Vibe-Coded Version#
The Declarative Version#
Both produce the same result. But the second version gives you for free:
- Incremental updates: Add a new doc → only the new doc is chunked, embedded, and indexed. Already-processed docs are untouched.
- Automatic versioning:
chunks.history()shows every change.chunks.revert()undoes the last one.pxt.get_table('knowledge.chunks:5')queries any prior version. - Synchronized deletion: Delete a document → chunks, embeddings, summaries, and indexes are all cleaned up atomically. No zombie vectors.
- Error recovery: API call fails? Pixeltable retries with backoff. Pipeline crashes? Restart and it skips already-cached results.
- Full lineage: Every summary traces back to its chunk, which traces back to its document. Auditable by design.
Where It Gets Worse: Multimodal Applications#
The gap between demo and production is even wider for multimodal applications. A vibe-coded video analysis pipeline requires:
- Storing video files (S3)
- Extracting frames (FFmpeg scripts)
- Running detection models (GPU management)
- Generating descriptions (OpenAI Vision API)
- Extracting and transcribing audio (Whisper)
- Embedding frames and text (separate pipelines)
- Indexing for search (Pinecone × 2)
- Keeping it all in sync (Airflow + custom glue)
An AI coding assistant will happily write scripts for each step. But who synchronizes them? Who handles the case where frame extraction succeeds but detection fails? Who manages the dependency graph (embeddings depend on frames, which depend on videos)? Who ensures that adding a new video only processes that video, not everything?
This is where the infrastructure bottleneck is real. Not the intelligence, but the data management around it.
The Right Split: Vibe-Code the App, Not the Infrastructure#
Here's the practical advice. Use AI coding assistants for:
- Application layer: FastAPI routes, React components, UI logic
- Business logic: Custom UDFs, prompt engineering, domain-specific processing
- Integration: Connecting your Pixeltable backend to your frontend
Don't vibe-code:
- Data infrastructure: Storage, orchestration, retrieval, indexing
- Pipeline management: Incremental updates, dependency tracking, error recovery
- Operational concerns: Versioning, lineage, caching, rate limiting
Let declarative infrastructure handle the second category. Your AI coding assistant becomes dramatically more effective when it's building on top of a system that already provides storage, orchestration, and retrieval, instead of trying to recreate them from scratch with glue code.
The Future: AI Coding + Declarative Infrastructure#
As AI coding assistants like ChatGPT, Claude, and Cursor get more data on Pixeltable, something interesting happens: vibe coding with Pixeltable actually makes it both easy to ship AND easy to maintain.
When the AI assistant writes table.add_computed_column() instead of a custom ETL script, the resulting code is inherently production-ready. Incremental updates, versioning, caching, and lineage come for free. The AI didn't have to know about distributed systems. It just used the right abstraction.
This is already working in practice. Pixeltable ships with first-class support for AI coding tools: drop an AGENTS.md into your project for Cursor or Windsurf, install the Pixeltable Skill for Claude Code, or connect directly via MCP servers with 32 tools for creating tables, running queries, and executing Python, all from your AI editor. Even appending .md to any docs URL gives you an LLM-optimized version you can paste straight into any chat.
The result: your AI coding assistant generates Pixeltable code that's production-ready by default, because the abstraction handles the hard parts. Ten lines of declarative code replaces hundreds of lines of glue, and the AI gets it right on the first try because the API is simple enough.
This is why infrastructure abstraction matters more than intelligence abstraction. AI democratized the ability to write code, but it didn't democratize the ability to build robust data infrastructure. The infrastructure layer needs to make the right decisions on behalf of the user, so that what ships can also sustain.
Ship Fast. Stay Fast.#
The era of vibe coding is here. AI coding assistants aren't going away. They're getting better. The question isn't whether to use them, but what to use them on top of.
Build your application layer with AI assistance. Build your data infrastructure with declarative abstractions that provide operational integrity under change. The result: you ship as fast as any vibe-coded prototype, but what you ship actually works in production.
pip install pixeltable
Ready to build production-ready multimodal AI? Start with the 10-Minute Tour, set up your AI coding tool for Pixeltable, build a complete video pipeline in 20 minutes, or explore the App Template for a full-stack FastAPI + React scaffold. Everything is open source under Apache 2.0.
