# From AI prototype to team tool: a supported path for non-engineers

> Colleagues outside engineering were building real tools with AI. Here is how we gave that work a safe path from prototype to something a team can rely on.

Published: 2026-11-14
Author: Vishal Bhargava
Canonical URL: https://vbhargava.org/writing/paved-road-for-ai-built-tools/
Tags: platform-engineering, AI, developer-experience
Series: paved-road

---
> **Part 1 of 2.** In part two, I'll share more practical details of the workflow, from checking an agent's changes to releasing them. Coming soon.

AI is changing who gets to turn an idea into software. The people closest to a problem can now do much more of the building themselves: describe what they need, try the result, and refine it. For a company, that opens up ideas that would otherwise wait for engineering time.

At Kittl, we were seeing this alongside our work on an [AI-first design product](https://www.kittl.com/discover/ai). Colleagues outside Engineering were using AI to build forms, trackers, and small applications for their own teams. These tools often sat outside the core product roadmap, but their value was clear to the people doing the work. People were coming to me with something they had already built and asking for help taking it further.

There was a lot to preserve in that way of working. The builder understood the problem, could judge the result, and could keep improving it while the details were fresh. Sharing the tool introduced responsibilities that were harder to judge from a working screen: how information was handled, who could access it, how changes would be checked, and who would look after it. The AI could generate the application without making those responsibilities clear to the person asking for it.

The projects also arrived in different forms. Some were local files or code inside an AI conversation; others were running through independently chosen services. People were using different AI tools, often letting them choose the technical approach, and some had never used Git or GitHub. Helping each person get something working was one thing. Finding a consistent way to support all of this work, with people able to keep building independently, was a larger engineering problem.

Taking over every application would put those ideas back in competition with core product work. Reviewing every finished, AI-generated application in depth would create another queue, with engineers learning a new system before they could judge it. We needed engineering practices built into the way people worked, so that each new tool did not require the same decisions and explanations from scratch.

That became **Paved Road**, applying an established idea from platform engineering (A paved road is a supported, well-maintained way of building and shipping software that a platform team offers to everyone else. You can go off it, but staying on it means the hard decisions are already made for you.) to a new group of builders. The builder judges whether the tool solves the right problem. The agent (An AI tool that goes beyond suggesting code and carries out the work: editing files, running commands, and reading the results.) carries the change through the repository and its checks. Platform supplies the starter applications and shared checks, handles initial setup, and takes on exceptions. That gives each idea a supported path from an experiment to something other people can use and rely on.

## Start from what the tool needs to do

For that path to work, the first choices had to make sense to the person building the tool. Asking them to select a framework or explain a deployment architecture would leave them relying on the AI's defaults again.

The guide began with their intent: what should the tool do, does it need to remember information between visits, who should use it, and what information will it handle? Those answers helped determine a suitable starting application and whether the idea needed closer review. Consider a form a team uses to collect requests: it needs to save submissions and make them available to the right people. Those are needs the builder can describe through the work they want to do.

For someone who already had a prototype, the same questions became a way to understand what they had built. The guide included instructions for asking an agent to inspect the project and explain its data, connections, access, and current setup in plain language. That report gave the builder and Platform something concrete to discuss and verify. The useful idea could carry forward while technical choices made during the experiment were reconsidered.

The supported starter gave the agent an application structure to build within and an established place to run. We standardized hosting on [Cloudflare Workers](https://developers.cloudflare.com/workers/), using [D1](https://developers.cloudflare.com/d1/) for apps that needed a database.

For internal tools, [Cloudflare Access](https://developers.cloudflare.com/cloudflare-one/access-controls/), part of Cloudflare Zero Trust, handled sign-in and controlled who could reach the app. Once someone signed in, the app could use their identity to apply its own permissions, such as who can submit the request form and who can read its responses.

The application also needed to outlive the conversation that created it. Its code lived in a shared repository (The place a project's code lives, with a full history of every change and who made it. Here, on GitHub.), with version history, a named owner, and a record of its intended use. That provided a place for the next change and enough context for someone else to understand the work. Keeping the instructions with the project also helped preserve the builder's choice of AI tool: another capable agent could work from the same code and expectations.

The repository also introduced steps between changing that form and getting the change to other people.

## Let the agent handle the Git work

An early version of the guide left those steps with the builder: edit the project files and open a pull request (A proposed change to the code, shown as a before-and-after so it can be checked before it becomes part of the project.). For someone who had never used GitHub, "open a pull request" was a wall, written down as if it were a step.

Writing a step down had not made it doable for the person expected to carry it out. We rewrote the guide around who did what and made routine GitHub work part of the agent's instructions.

For the request form, adding a field starts with a change within the supported structure. The agent runs local checks and shows a preview. The builder assesses whether the field asks the right question and whether the interaction makes sense, then keeps asking for changes until they're happy.

When the builder approves the result, the agent creates a branch, prepares the pull request, and reads the automated results. The builder keeps judging the form without having to perform the Git commands.

Those results come from a common set of checks for concerns such as exposed credentials, known vulnerabilities in dependencies (Most software is built on other people's published code. When a security flaw is found in one of those pieces, any tool using it inherits the flaw until it updates.), and departures from the supported application structure. Platform maintains that baseline centrally, so each new tool uses the same conventions.

If adding the field introduces a type error, the agent reads the failure and corrects the code, then explains what changed. Its instructions rule out weakening a check to make it pass. Instructions shape what an agent tries to do; they don't guarantee it. Keeping a failed check from being bypassed is a platform responsibility, which I'll return to in part two.

Some blockers need Platform. If the agent lacks access to submit the change, it explains what is missing and what the builder should ask for. That gives the person a next step without asking them to diagnose an unfamiliar toolchain.

## Match the review to the risk

Each app recorded its intended audience, the data it handled, and whether it connected to production systems (The live systems customers and the business actually depend on, as opposed to test or internal ones.). Those details determined its **risk tier**: the controls and review it needed. The request form, collecting internal requests from colleagues, could ship through the automated checks alone. If it started collecting customer details, the same change would need human review before it went anywhere.

Before other people can use the request form, Platform completes its initial setup. The guide flags that dependency early, so it doesn't arrive as a surprise. Once deployed, the form needs to be checked with its intended users: the preview helps someone judge the interaction, while the deployed version shows whether people can sign in and use it.

For one team, that supported path took a dashboard beyond its creator's computer. Previously, the team had no consistent way to access it or contribute. On Paved Road, they could return to the same shared tool, add comments, and update its content together. Platform handled the initial setup; the team could keep working with it from there.

If similar tools are appearing in your company, start with one low-risk tool and follow an ordinary change from the builder's request to something another person can use. Note what the builder can judge, what the agent can carry through, and where engineering is still needed. Those handoffs give you a concrete first workflow to support, and a way to see whether it helps someone finish the next change.

---

*In part two, I'll work through a fictional application to make those practical details concrete: testing who can change its data, protecting the checks, and carrying a verified change into a release.*
