How a non-developer builds production-ready software with AI agents — and what is still missing.
Companion to my talk “My Agentic Stack as a Non-Developer: A CEO on the Path to Enterprise-Grade,” given at the Agentic Shift Meetup in Dortmund, June 2026.
I didn’t start my career as a developer — I started in product management. And yet a meaningful share of the software I need now takes shape under my own hands, with AI agents. This isn’t hobbyist tinkering: it’s about tools that run, get maintained, and have to meet a standard.
That’s the interesting part. Not that a CEO “clicks something together,” but that agentic tooling has lowered the threshold for building serious software so far that the old line between “builds software” and “understands software” is blurring. What replaces that line is discipline — not a diploma.
Why a CEO builds at all
The reflex is to treat this as a gimmick. It isn’t. Whoever owns a product knows its requirements better than any intermediary. When the path from idea to a working, verifiable state takes hours instead of weeks, it shifts who can — and should — do what.
This matches the core thesis of Agentic Engineering: writing code stopped being the bottleneck long ago; specification, review, and quality assurance are. That’s precisely where someone with product and leadership perspective adds substance. The agent handles tasks; the human makes decisions.
The core: Claude Code, slash commands, subagents
The heart of the stack is Claude Code. It’s not just a chat next to the editor but an agent with access to files, terminal, and tools — it works inside the project, not beside it.
Two things turn it into a repeatable stack rather than a series of one-off prompts:
- Custom slash commands encapsulate recurring workflows — from creating a feature to a release step. What a human would otherwise rephrase every time becomes a named, versioned command.
- Subagent architecture delegates well-scoped subtasks to specialized agents — research, implementation, review. Each subagent has a narrow brief, which makes results more reliable and easier to follow.
The template repository: scaffolding with guardrails
Every new project starts from a base template repository. This is the single biggest lever for quality: instead of starting from zero, each project ships the guardrails from day one — CI, static types, tests, linting, a clear project structure, and the conventions the agent is expected to follow.
This is the practical implementation of the six guardrails from the Agentic Engineering approach: they aren’t something you “add at the end,” but the precondition for letting an agent work with reduced supervision at all. The template makes the guardrails the default, not the exception.
Skills + MCP: the integration pattern
Two building blocks make the stack carry beyond a single repository:
- Skills are reusable capabilities — encapsulated knowledge and workflows the agent uses across projects instead of re-explaining them each time.
- MCP servers (Model Context Protocol) are the controlled bridge to external systems — data, tools, services. The agent gets access, but within clearly defined boundaries.
The pattern behind it: skills describe what the agent can do; MCP servers provide controlled access to what it needs. Together they make a stack that stays extensible without giving up control.
What “enterprise-grade” means — and where it still falls short
“Enterprise-grade” is not a label but a bar: reproducibility, security, compliance, observability, maintainability. A tool that only works on my machine is not an enterprise tool — it’s a prototype having a good day.
Staying honest: my stack already clears the bar in some places — deterministic builds, tests, clear structures. In others there’s road ahead: end-to-end secrets and access concepts, complete audit trails, scaling beyond the single case. Naming those gaps isn’t an admission of weakness — it’s the actual work order.
From a personal stack to a delivery model
My stack is, in miniature, what has to be thought through at scale as a delivery model. That’s exactly where Silicon Shoring comes in — the Reply Group’s AI-powered software delivery model, which orchestrates the same principles across the full lifecycle in an enterprise-grade way. The discipline behind it remains Agentic Engineering; the tooling is deliberately best-of-breed (Claude Code, MCP) rather than tied to a single vendor.
The best proof that Agentic Engineering holds up is when someone without a classic developer background uses it to build production-ready software. That’s where it starts to get interesting — and where the work of the next few years lies.
