Revolte.ai is not a coding assistant. It automates software delivery: it reads how your existing system already works, builds workflows that fit it, and runs up to 100 of them in parallel, from ticket to production. Teams ship sooner and better, and people approve every step that matters. I led its product design end to end and wrote its requirements as business analyst, from first concept to public launch.

Took the product from an evolving technical vision to a public launch.
Screens and states designed, across 22 end-to-end flows.
Product pillars unified in one workspace: Pre-build, Build, Observe, Govern.
Product of the Day on Product Hunt at launch.
Code assistants were everywhere, but delivery still meant repositories, context, reviews, approvals, deployments and cost, all spread across different tools. Revolte set out to bring the whole lifecycle into one place.
Context, requirements and repository analysis before an agent touches code.
Agent workflows that plan, write, test and verify changes.
Progress, logs, code changes and deployment health in real time.
Approvals, credits, budgets and team access for organisations.
Early versions worked technically, but the people we needed to win could not see, steer or justify what the agents were doing.
No way to see what an agent was doing, why a run failed, or what it was about to change in the codebase.
No approval gates, no cost visibility, and no clear line between experimenting and shipping to production.
Users had to configure a project and an application before they could even see what a workflow would do.
make a powerful multi-agent system feel simple to start, transparent while it runs, and safe to trust with real code?
I sat between product, engineering and QA. Writing the requirements and designing the interface myself meant every screen was shaped by real constraints.
Before drawing a single screen, I mapped the market, the people and the capabilities, then decided what the first version must prove.
I benchmarked AI coding assistants, autonomous agents and workflow builders against the full delivery lifecycle. The gap after code generation became our positioning.
| Capability | Code gen | Context | Review | Approvals | Deploy | Cost |
|---|---|---|---|---|---|---|
| AI code assistants | ||||||
| Autonomous agents | ||||||
| Workflow builders | ||||||
| Revolte |
Each role needed a different depth of detail from the same run.
I scored every capability on user value, setup effort and execution dependencies, separating what a run must have from what is optional.
I studied terminals, pull request reviews, diffs and logs so Revolte would feel familiar on day one, not like another dashboard to learn. These patterns became the vocabulary of the product.
Let people see and run something before asking them to configure anything.
Every agent action is observable: the stage, status, logs and every file it changed.
AI proposes, people approve. Nothing reaches the codebase without review.
The As-Is / To-Be mapping was the turning point. I traced every configuration dependency and showed where each one could safely be resolved later.
From the first prompt to a governed, observable delivery pipeline. Each moment shows the screen and the components that carry the decision.
People arrive with an idea, a proven template or an existing repository. Every path converges on the same guided first run.


Three focused questions with recommended answers turn a vague prompt into a clear brief. A progress rail shows exactly where the work stands.



A short, readable plan with approve or request changes. Once approved, tasks run live with every file edit visible as it happens.



A resizable split shows the diff beside the file tree, with a commit message before anything is pushed. Engineers review AI work the same way they review a teammate's.


Triggers, agents, conditions and actions on a calm canvas. Configuration lives inside each node, and loops are drawn as plain language: "Else: retry, up to 3 times".


I defined how approve and reject route a run. The gate shows exactly what was checked, and a rejection goes back to the Developer agent with your note.



Checks before deploy, a validated config and a clear live state. Project dashboards turn delivery into DORA metrics leaders already trust.


I mapped credits across organisation, project and application levels, and how low balances affect whether a run can start. Billing shows plan and extra credits in plain terms.


With QA, I turned business rules into acceptance scenarios for every failure: missing setup, rejected approvals, failed runs, lost connections and empty credits.



A product this broad only holds together with strong foundations. I set the brand direction, components, copy rules and motion, and mentored designers to keep them consistent.
A custom typeface for brand and product, tuned to read cleanly in dense, code-heavy interfaces.
Dark-first product, warm light marketing. Colour is reserved for status and the one action that matters.
One shared vocabulary across chat, runs, deploys and billing.
I wrote the user stories, process flows and handoff specs, defined reporting requirements for runs, and worked with QA on expected behaviour for every edge case. AI tools such as Claude, ChatGPT and Figma AI helped me organise requirements and prototype scope questions faster.

In AI products, trust is the feature. People adopt an agent only when they can see what it is doing, and stop it when they need to.
Next, I would instrument activation from day one, test the studio with larger teams, and extend governance for enterprise roles.