I wanted a support console that agents could use: create tickets, update their status, and add comments, with a separate backend and persistent storage. The goal included a deployed system and a way to review later changes.
Claude Code handled the implementation and used Bit's tools to build, validate, and deploy it. The result was a Vite React app, an Express service, MongoDB persistence, and a hosted console with HTTPS.
Bit Cloud gives a single project the build, CI, hosting and database it needs from its first component, and lets coding agents such as Claude Code, Cursor and Codex work on it over MCP. Bit, the open-source build system underneath, keeps each part as a versioned component, so the next app starts from what the first one built.
Disclosure: Iām an engineer at Bit. I explicitly instructed Claude to use Bit in this build because it's the fastest way to give an AI agent the scaffolding it needs to generate a deployed, multi-service app.
The prompts below are reconstructed examples summarizing the session. The first example covers the core system and database setup; authentication was added in a subsequent stage.
Start with the system you want to run
The first instruction put Bit into Claude's workflow. This example combines that instruction with the eventual deployment goal:
Build a small customer support platform using Bit. Create a React app
and a separate Express ticket service, composed into one platform.
Agents should be able to create tickets, update statuses, and comment.
Add MongoDB persistence using MONGO_URL, validate the system, and
prepare a deployment with a preview I can review.
The session already had a Bit workspace and Cloud access. Claude used MCP to inspect available APIs and local Bit tools to create and validate the code. I directed the work through prompts and reviewed the results.
What Claude delivered
The frontend owns the ticket queue and forms. The backend owns ticket operations and storage. A platform definition connects the app and service through a gateway and declares how they run together.
flowchart LR
Browser[Support agent browser] --> App[Vite React frontend]
App --> Gateway[Platform gateway]
Gateway --> Service[Express ticket service]
Service --> Mongo[(MongoDB)]The app uses BACKEND_URL for the local gateway and a same-origin fallback in the recorded deployment. Requests reach the service through /support-service; the frontend does not need its listening port. The backend reads the managed MongoDB connection from MONGO_URL.
Development tools provide compilation, type checking, linting, and tests across the app and service. Ripple CI, Bit Cloud's build and deployment service, builds submitted changes and produces a staging preview. The console now also has a production deployment with HTTPS included.
Try the production support console or inspect the project on Bit Cloud.
I did not write a separate hosting stack for this demo. Bit supplied hosting, service connectivity, database provisioning, and deployment builds. Claude implemented the application and its tests; I remained responsible for review. The Bit Cloud launch post describes the managed deployment capabilities.
One test limitation matters: MongoDB integration tests can skip when their temporary database cannot start on the CI runner. A green build does not prove those tests ran. A local restart check did confirm that a new ticket and comment survived restarting the platform against the same MongoDB.
Give the next request the existing system as context
Building with Bit also makes the project inspectable through MCP. Published components expose API references and dependency metadata, so Claude can retrieve the current interfaces instead of relying only on the conversation. Bit generates and persists that metadata as part of the component lifecycle; it is available to tools as well as developers. The metadata reference explains how it is maintained.
That context complements the source code. HTTP routes and runtime behavior still need inspection and tests; an exported TypeScript API does not describe every REST interaction.
The next request was authentication:
Add simple username and password authentication with a predefined
demo account. The API must verify tokens on ticket requests.
Update the frontend to sign in and send the token.
Claude added login endpoints, HMAC-signed bearer tokens, and protection for ticket routes. It updated the app with a login screen, session handling, and authorization headers. The existing platform composition and gateway remained in place.
After deployment, HTTP checks returned 401 for ticket requests without a token and returned tickets after login. The authentication build in Ripple CI records that iteration.
Claude could update the API and app within the existing architecture, then deliver a running preview to review. Bit provided the project context and deployment infrastructure underneath that work.
This remains a demo: replace its predefined account and public signing secret before handling customer data. Concurrency controls, migrations, recovery procedures, and mandatory database integration tests also need work.
Top comments (1)
Thanks for sharing šš»