AI is helping developers write code faster than ever. Tools like Cursor, Claude, and GitHub Copilot can generate features, fix bugs, and even open pull requests for you. But while software development is getting faster, software operations haven't really changed that much. Most teams are still relying on Slack messages, deployment runbooks, approval chains, dashboards, and a lot of operational knowledge that lives inside the heads of a few senior engineers.
That's becoming a real problem. If AI is generating more code than ever, eventually the bottleneck stops being writing software and starts becoming safely getting that software into production. The obvious solution might seem like letting AI agents handle deployments themselves, but that's probably not a great idea. Giving an AI agent direct access to production infrastructure is how you end up learning very quickly why guardrails exist in the first place.
So, we're going to build something a little more practical. We'll create an AI-assisted deployment system that watches for code changes, uses AI to review the diff and generate a risk report, sends that report to Slack for human approval, deploys the application if it's approved, and automatically logs everything into an internal operations dashboard.
To build this, we'll use Superplane. Superplane is a new open-source control plane designed for software delivery and operational workflows. The idea is pretty simple: let AI handle repetitive operational work, let humans stay in control of critical decisions, and put the entire process into a system that's actually observable and auditable.
Starting from the canvas, not a script
I'm already inside Superplane, and the first thing you'll notice is that everything revolves around these apps. This is an important distinction because we're not building a one-off deployment script here. Traditional automation usually ends up scattered across CI pipelines, shell scripts, Slack bots, and random internal tools. What Superplane is trying to do is bring all of that into a single operational application where workflows, approvals, agents, and dashboards all live together.
So, let's create a new app and call it AI-gated deployment. Once the app is created, we land inside the canvas. Think of this as a place where we visually define how operational work flows through the system. Every block represents an action, a trigger, an approval step, or some piece of logic, and we connect them together to build a workflow.
The first thing we need is a trigger. Since we want this workflow to start whenever code changes are pushed, I'll drag in a GitHub on push node. Now, whenever someone pushes code to our repository, Superplane will receive the event and start a new execution automatically.
At this point, the workflow can already react to code changes, but it still has no idea whether those changes are risky or completely harmless. So, the next thing we need is an AI analyst.
Letting AI do the risk review, not the decision
I'm going to add a Claude agent node and connect it directly to the GitHub trigger. The goal here isn't to let AI make deployment decisions. Instead, we're using AI to gather context and summarize information that a human would normally have to review manually.
For the prompt, I'll keep it pretty simple:
Act as a senior SRE. Review this Git diff. Identify any database schema changes, infrastructure modifications, or potential security risks. Output a concise three-bullet-point risk summary.
Then we'll pass the GitHub diff directly into the prompt so Claude can see exactly what changed.
All right, so now we have the AI side working. A code change comes in, Claude reviews the diff, and generates a risk summary. But we're still missing the most important part of the workflow, which is the human approval layer.
This is actually where the entire philosophy behind Superplane starts to show up. A lot of people talk about autonomous agents running production systems, but most engineering teams aren't comfortable giving an AI agent complete control over deployments. What they want is assistance, not autonomy. They want the AI to do the repetitive work while humans remain responsible for the final decision.
Adding the human approval layer
So, let's build exactly that. I'm going to drag in a Slack wait for button click node and connect it directly to the Claude agent. What this does is pause the workflow and send a message directly into Slack. The workflow won't continue until somebody explicitly approves or rejects the deployment.
For the message itself, let's include the AI-generated risk summary, the commit information, and a link back to the pull request so reviewers have all the context they need. Then we'll add two buttons: Approve and Reject. Now, whenever a deployment is ready, the team gets a clear summary of the changes, the potential risks, and a simple way to make a decision without digging through logs or manually reviewing every file.
Next, we need to tell the workflow what happens after that decision is made. So, I'll add an if node and connect it to the Slack approval step. The condition is pretty simple: if the user clicked approve, we'll continue down the deployment path. If they clicked reject, we'll stop the workflow and log the result.
For the approval path, I'm going to connect it to a deployment node. You can use whatever platform makes sense for your stack. At this point, we have a complete approval workflow. Code gets pushed, AI reviews the change, a human reviews the AI's recommendation, and only then does the deployment move forward.
But before we test it, I want to add one more thing that most deployment pipelines completely ignore. And that's memory.
Giving the workflow a memory
I'm going to add an add memory node right after the deployment step. Memory is basically Superplane's persistent storage layer. Instead of throwing away information when a workflow finishes, we can save it and use it later.
Let's create a namespace called deployments. For every approved deployment, I'm going to store a few things: the commit ID, the AI risk summary, the person who approved the deployment, the deployment timestamp, and the deployment status. Now, every time this workflow runs, we'll automatically build a historical record of what happened.
This might seem like a small addition, but it's actually one of the reasons I like this approach. Operational knowledge stops living in random Slack conversations and starts living inside the system itself.
Building a live deployment dashboard
Now, let's make that information visible. I'm going to switch over to the console tab. Think of the console as a custom operational dashboard that sits on top of the workflows and memory we've already created.
Let's add a table widget. For the data source, I'll point it directly at our deployments memory namespace. And just like that, we have a live deployment dashboard. Every approved deployment will automatically appear here with the associated metadata. No manual updates, no spreadsheets, and no separate internal tooling required.
We can also add a metrics widget above the table to show things like total deployments, deployment success rate, or the number of deployments approved this week. What's interesting is that we're not just building a workflow anymore. We're building an operational application.
Putting it all to the test
Now, let's actually put this thing to the test and see what happens when we push a real code change through the system.
Over in my editor, I'm going to make a small change to the application. Nothing major, just enough to trigger the workflow. I'll commit the change, push it to GitHub, and now we should see Superplane kick off a new execution automatically.
If we jump back into the canvas, you can already see the run moving through the workflow. The GitHub trigger fires, Claude receives the diff, and a few seconds later, we get our risk summary.
Now, let's check Slack. There it is. We can see the AI-generated report along with the commit details and the approval buttons. In this case, the change looks fine, so I'll go ahead and click approve.
The moment I do that, the workflow resumes automatically. Superplane routes down the approval path, executes the deployment, and records the result in memory. And this is where everything comes together.
If we head over to the console, the deployment record is already there. We can see the commit, the AI summary, who approved it, when it happened, and the final deployment status. What's nice about this is that every deployment now follows the exact same process. The review is consistent, the approval is tracked, the deployment is logged, and the entire history is available in one place.
Key Takeaways
- AI is speeding up development, but operations are still a manual bottleneck. The problem isn't writing code anymore, it's getting it safely into production.
- Giving an AI agent direct access to infrastructure is dangerous. Instead, we should let AI do the grunt work (reviewing diffs, summarizing risks) while humans keep the final say.
- With Superplane, we built a single operational app that combines a GitHub trigger, an AI risk review, a Slack approval step, a deployment action, and persistent memory, all on one canvas.
- Adding memory to the workflow means every deployment is logged automatically. You no longer dig through Slack threads to find out what happened.
- The console turned that logged memory into a live dashboard with no extra tooling, making the entire process observable and auditable.
In just a few minutes, we went from a blank canvas to a complete AI-assisted deployment application. As AI makes it easier to write and ship code, the challenge shifts to operating that code safely in production. Instead of scattering approvals, workflows, dashboards, and operational knowledge across different tools, Superplane brings them together into a single system where AI handles the repetitive work and humans stay in control of critical decisions.
Superplane just launched its open-source beta. If you'd like to try it yourself, check out the docs and start building your own operational apps. Thanks for reading, and I'll see you in the next one.