How We Used an AI Agent to Skip the DevOps Grind
When I read Andrej Karpathy’s post on building MenuGen, what stood out was the all-too-familiar arc, the initial joy of spinning up a quick prototype, followed by the slow grind of making it production-ready. The creative sprint gives way to a marathon of plumbing, wiring up APIs, juggling secret keys, wrestling with deployment quirks, and stitching together services just to make sure the app doesn’t vanish when you hit refresh.
That experience sparked a question: could we keep the creative, vibe-coding flow while automating all the plumbing? We set out to find the answer by rebuilding MenuGen, combining a simple product brief from a large model with an implementation agent in VS Code. But we almost hit the same wall Karpathy did. Our agent could dream up the code, but it was like an architect who’d never seen the building site, it was completely blind to our actual infrastructure.
The breakthrough for us was finding a way to give the agent a pair of eyes. We used WSO2’s Choreo platform, whose Model Context Protocol (MCP) server acted as that crucial link, giving our AI a real-time “cheat sheet” to our services, APIs, and deployment targets.
From Idea to Local App
Like the original project, ours began with a clear idea. We used Gemini 2.5 Pro within VSCode to produce a concise Software Design Document (SDD) outlining the core components:
- An OCR step to extract menu items.
- An image generation step to visualize them.
- A simple web UI.
With that Software Design Document in hand, we handed it to a Claude Sonnet 4.0 agent in VS Code with a single, crucial instruction.
This prompt contains two key instructions. The first, “implement this app” is the straightforward task of code generation. The second part, however, is what sets this process apart and directly addresses the “painful slog” of productionizing a prototype: “using the Choreo Marketplace.”
By instructing the agent to use the marketplace as its source of truth for APIs, we preemptively solve the problem of hunting for endpoints, wrestling with deprecated docs, and manually managing secret keys. This is the bridge between intent and infrastructure that will be critical later on.
This automated correction is a key part of the process. Armed with the correct-by-definition API specs from the marketplace, the agent didn’t just write code, it wrote the right code. It then proceeded to translate the entire design document into a working local repository.
The agent delivered a complete repository with a React frontend and a Go backend. It included a detailed README.md with clear instructions for local setup, from the docker run commands to the required .env configuration. This provided all the basic plumbing to iterate quickly on a laptop. This brings you to that exhilarating ‘80% done’ feeling that Karpathy described, the fun part of the project.
Automating the “Painful Slog” of Integration
The initial prototype is the fun part where you feel 80% done. The remaining 20%, as Karpathy noted, is often a “painful slog” of wrestling with deprecated APIs and out-of-date docs. This is where our path diverged sharply from the original. For us, this entire step was automated because we instructed the agent to use the Choreo Marketplace.
An AI agent’s code is only as reliable as its knowledge, which can be months or years out of date. This is why it might generate calls to endpoints that no longer exist. The marketplace solves this by acting as a live, guaranteed source of truth.
It contains connectors for common public APIs like OpenAI, but critically, it also allows you to register your own internal or third-party services. We had already registered Replicate this way, making its API discoverable and standardized for our agent.
Instead of hallucinating API calls, the agent queried this marketplace. It received the up-to-date OpenAPI specs and direct references to secrets managed within Choreo, and used this correct-by-definition information to automatically wire both integrations into the Go backend. No more hunting for endpoints or pasting stale code snippets.
From Laptop to Live in One Go
With the code working locally, we arrived at the final headache: deployment. For this, we gave the agent a simple, conversational prompt: ”Can you deploy this on Choreo?” What followed was an intelligent, multi-step process orchestrated entirely by the agent and Choreo’s MCP server. It was like watching an expert DevOps engineer work at machine speed.
1. Analyze and Plan
First, the agent analyzed the entire project repository, the Go backend and the React frontend to understand the application’s structure and dependencies. This initial reconnaissance was crucial for formulating a deployment strategy.
2. Deploy the Backend
Get Isala Piyarisi’s stories in your inbox
Join Medium for free to get updates from this writer.
Based on its analysis, the agent generated a component.yaml manifest file defining a backend component. It then built and deployed the initial version of the backend service to Choreo. Getting the API live first is a critical step in a modern deployment workflow.
3. Provision and Publish the Database
Next, the agent requested a managed PostgreSQL database from Choreo. Once provisioned, it immediately published the new database as a service in the Choreo marketplace, making it a discoverable and connectable resource for other components.
4. Wire Up the Backend Connections
With the database and third-party services available in the marketplace, the agent updated the component.yaml manifest. It added “Choreo Connections” to formally link the backend to the database, OpenAI, and Replicate services, then redeployed the backend with this new, complete configuration.
5. Implement and Deploy the Frontend with Auth
The agent then turned its attention to the frontend. It scaffolded sign-in and sign-out buttons in the React UI and wired them to Choreo’s managed authentication endpoints. After generating the frontend component definition, it built and deployed the frontend.
6. Secure the Final Connection
With both frontend and backend live, the agent made the final crucial link- connecting the web app to the backend. This ensures all communication flows through Choreo’s secure gateway, protecting the API and managing user sessions.
7. Create Test Users
As a final touch, the agent used Choreo’s Secure Token Service (STS) to automatically create a handful of test users, allowing us to immediately sign in and test the end-to-end flow of the live application.
In just a few minutes and from a single conversational prompt, the process took the project from a local repository to a fully wired, secure, and live cloud architecture. Suddenly, the abstract components from the initial SDD became tangible, live services, fully interconnected and managed by the Choreo platform.
This entire system was automatically assembled and brought to life, culminating in the final, user-facing application.
What would normally be a multi-hour, error-prone manual task was reduced to an automated, repeatable workflow, orchestrated entirely by the agent.
Solving the Hard Problems Automatically
This automated flow highlights a fundamental shift. The innovation isn’t just that an AI can write code, it’s that a tight integration between an implementation agent and a deployment platform can automate the vast majority of platform engineering friction. This approach didn’t just save time, it elegantly solved the very problems that made the original MenuGen journey a “painful slog”:
- The Database Problem: What Karpathy called a source of “more suffering” was reduced to a single request. The agent asked for a database, and Choreo provisioned and connected it, enabling persistence and a robust processing queue.
- The Authentication Maze: Instead of manual OAuth configuration, the agent leveraged Choreo’s managed auth, injecting credentials at runtime so the same build works across any environment.
- The Secret Key Scavenger Hunt: The .env.local headache disappeared. All keys were stored in Choreo’s secure vault and injected automatically at runtime. The plumbing just worked.
This entire end-to-end process, from idea to a live, secure application, started with the same conversational prompt we used to generate the initial design document:
I want to create POC for a Menu Visualizer app as follows,
- Users photo a restaurant menu for upload
- Go (single file) backend extracts menu content with GPT-4o XML structured output and generates dish images using Replicate (polling) API
- PostgreSQL DB (with gorm) stores menu text and all image blobs
- React (plain css) app displays the results
Create a complete SDD.md for this app?If you want to explore the final result or reproduce this workflow yourself, all the resources are available:
- Final Application Code: The complete source code for the MenuGen rebuild is available from,
- Replicate OpenAPI Specification: To make the Replicate API discoverable in the Choreo Marketplace, we created a custom OpenAPI spec. You can find the replicate-openapi.yaml file in the project repository.
- Connecting the Dots (Choreo MCP Server): This is the secret sauce that makes the agent platform-aware. This article walks you through how to configure it.
Karpathy’s experience was a perfect diagnosis of a widespread problem: the operational complexity that smothers creative momentum. By giving the AI agent a reliable, auditable bridge to the underlying infrastructure, the developer stays focused on the product. You get to remain in that exhilarating “vibe coding” moment, while the repetitive, painful plumbing that turns prototypes into production systems is handled for you.
